MATLAB script to generate reports of rounding errors in algorithms

I am interested in use or created an script to get error rounding reports in algorithms. I hope the script or something similar is already done... I think this would be usefull for digital electronic system design because sometimes it´s neccesary to study how would be the accuracy error depending of the number of decimal places that are considered in the design. This script would work with 3 elements, the algorithm code, the input, and the output. This script would show the error line by line of the algorithm code. It would modify the algorith code with some command like roundn and compare the error of the output. I would define the error as

Errorrounding = Output(without rounding) - Output round 

For instance I have the next algorithm

calculation1 = input*constan1 + constan2 %line 1 of the algorithm
output = exp(calculation1)               %line 2 of the algorithm

Where 'input' is the input of n elements vector and 'output' is the output and 'constan1' and 'constan2' are constants. n is the number of elements of the input vector

So, I would put my algorithm in the script and it generated in a automatic way the next algorithm:

input_round = roundn(input,-1*mdec)
calculation1 = input*constant1+constant2*ones(1,n)
calculation1_round = roundn(calculation1,-1*mdec)
output=exp(calculation1_round)
output_round= roundn(output,-1*mdec)

where mdec is the 开发者_如何学Gonumber of decimal places to consider. Finally the script give the next message

The rounding error at line 1 is #Errorrounding_calculation1

Where '#Errorrounding' would be the result of the next operation Errorrounding_calculation1 = calculation1 - calculation1_round

The rounding error at line 2 is #Errorrounding_output

Where 'Errorrounding_output' would be the result of the next operation Errorrounding_output = output - output_round

Does anyone know if there is something similar already done, or Matlab provides a solution to deal with some issues related? Thank you.

---

First point: I suggest reading What Every Computer Scientist Should Know About Floating-Point Arithmetic by David Goldberg. It should illuminate a lot of issues regarding floating-point computations that will help you understand more of the intricacies of the problem you are considering.

Second point: I think the problem you are considering is a lot more complicated than you realize. You are interested in the error introduced into a calculation due to the reduced precision from rounding. What you don't realize is that these errors will propagate through your computations. Consider your example:

output = input*C1 + C2

If each of the three operands is a double-precision floating-point number, they will each have some round-off error in their precision. A bound on this round-off error can be found using the function EPS, which tells you the distance from one double-precision number to the next largest one. For example, a bound on the relative error of the representation of input will be 0.5*eps(input), or halfway between it and the next largest double-precision number. We can therefore estimate some errors bounds on the three operands as follows:

err_input = 0.5.*eps(input);  %# Maximum round-off error for input
err_C1 = 0.5.*eps(C1);        %# Maximum round-off error for C1
err_C2 = 0.5.*eps(C2);        %# Maximum round-off error for C2

Note that these errors could be positive or negative, since the true number may have been rounded up or down to represent it as a double-precision value. Now, notice what happens when we estimate the true value of the operands before they were rounded-off by adding these errors to them, then perform the calculation for output:

output = (input+err_input)*(C1+err_C1) + C2+err_C2
%# ...and after reordering terms
output = input*C1 + C2 + err_input*C1 + err_C1*input + err_input*err_C1 + err_C2
%#       ^-----------^   ^-----------------------------------------------------^
%#             |                                   |
%#    rounded computation                      difference

You can see from this that the precision round-off of the three operands before performing the calculation could change the output we get by as much as difference. In addition, there will be another source of round-off error when the value output is rounded off to represent it as a double-precision value.

So, you can see how it's quite a bit more complicated than you thought to adequately estimate the errors introduced by precision round-off.

---

This is more of an extended comment than an answer:

1. I'm voting to close this on the grounds that it isn't a well-formed question. It sort of expresses a hope or wish that there exists some type of program which would be interesting or useful to you. I suggest that you revise the question to, well, to be a question.
2. You propose to write a Matlab program to analyse the numerical errors in other Matlab programs. I would not use Matlab for this. I'd probably use Mathematica, which offers more sophisticated structural operations on strings (such as program source text), symbolic computation, and arbitrary precision arithmetic. One of the limitations of Matlab for what you propose is that Matlab, like all other computer implementations of real arithmetic, suffers rounding errors. There are other languages which you might choose too.
3. What you propose is quite difficult, and would probably require a longer answer than most SOers, including this one, would be happy to contemplate writing. Happily for you, other people have written books on the subject, I suggest you start with this one by NJ Higham. You might also want to investigate matters such as interval arithmetic.

Good luck.