MATLAB: Find the precision of a value

decimaldecimal digitsdigitsfloating pointfprintfprecisionsigfigssignificant figuresstring

Hello,

Is there a function in matlab that returns the precision of a number? for example, if I have a number 5.34 i want it to return 0.01, if I have a number 4 I want it to return 1 etc..

Thanks in advance for your answers,

Best Answer

No doubt there will be disagreements over what it means for floating point numbers, but here is one solution which provides the least unexpected output by converting to string, converting the last non-zero digit to 1 and the rest to 0. I do not claim that it is fast, but it does seem to be reasonably robust.

function p = getprecision(x)
f = 14-9*isa(x,'single'); % double/single = 14/5 decimal places.
s = sprintf('%.*e',f,x);
v = [f+2:-1:3,1];
s(v) = '0'+diff([0,cumsum(s(v)~='0')>0]);
p = str2double(s);
end

and tested:

>> getprecision(5.34)
ans =  0.010000
>> getprecision(5)
ans =  1
>> getprecision(53400)
ans =  100

Notes:

keep in mind that 5.34 and 0.01 do not really exist in binary floating point numbers. See Adam's comment.
'%g' is an obvious choice, but is actually more complicated because it can return fixed point values with trailing zeros.

Related Solutions

MATLAB: How to find number of significant figures in a decimal number

This is not necessarily trivial to do reliably. In the first place, 31.456 is not representable in IEEE double exactly, so those trailing digits aren't really exactly all 0's anyway. E.g.,

>> num2strexact(31.456)
ans =
3.1455999999999999516830939683131873607635498046875e1

So, depending on how one prints the number out and how one sorts though all the trailing digits you can get a variety of answers. One approach might be to start with the exact string, as above, and then progressively round the last digit and re-read the result to see if you end up with the same IEEE double number. When it doesn't match, then you know you hit the smallest "significant" digit (assuming I understand what you mean by the term).

EDIT

OK, so here is a quick first cut at a function based on the idea above. Hasn't been extensively tested so caveat emptor. Seems to work for the few test cases I have thrown at it. Is not vectorized, although that could easily be done. (I hesitate to post this because I have this nagging suspicion that this could be done in a simpler way, but what the heck ...)

% SIGDIGITS returns significant digits in a numeric non-uint64 number.
% Returns "significant" digits in a number, in the sense that if you
% printed any fewer digits the reverse conversion would not equal the
% original number. I.e., the value returned from this function is the
% minimum number of digits you must print in order to recover the original
% number with a reverse conversion.
% Programmer: James Tursa
function n = sigdigits(x)
if( ~isnumeric(x) || ~isfinite(x) || isa(x,'uint64') )
    error('Need any finite numeric type except uint64');
end
if( x == 0 )
    n = 0;
    return;
end
x = abs(x);
y = num2str(x,'%25.20e'); % Print out enough digits for any double
z = [' ' y]; % Pad beginning to allow rounding spillover
n = find(z=='e') - 1; % Find the exponent start
e = n;
while( str2double(y) == str2double(z) ) % While our number is still equal to our rounded number
    zlast = z;
    c = z(e); % Least significant printed digit
    if( c == '.' )
        e = e - 1;
        c = z(e);
    end
    z(e) = '0'; % 0 the least significant printed digit
    e = e - 1;
    if( c >= '5' ) % Round up if necessary
        c = z(e);
        if( c == '.' )
            e = e - 1;
            c = z(e);
        end
        while( true ) % The actual rounding loop
            if( c == ' ' )
                z(e) = '1';
                break;
            elseif( c < '9' )
                z(e) = z(e) + 1;
                break;
            else
                z(e) = '0';
                e = e - 1;
                c = z(e);
                if( c == '.' )
                    e = e - 1;
                    c = z(e);
                end
            end
        end
    end
end
n = n - 1;
z = zlast(1:n); % Get rid of exponent
while( z(n) == '0' ) % Don't count trailing 0's
    n = n - 1;
end
n = n - 2; % Don't count initial blank and the decimal point.
end

MATLAB: I noticed a difference with round() at 15 decimal places, and I need to know why this is so.

It's OK, I found the answer. Floating point doubles are precise to 15dp only.

Wikipedia page

Best Answer

Related Solutions

MATLAB: How to find number of significant figures in a decimal number

MATLAB: I noticed a difference with round() at 15 decimal places, and I need to know why this is so.

Related Question