MATLAB Answers


how to make matlab display full number digits

Asked by Talaria on 6 Aug 2011
Latest activity Commented on by Steven Lord
on 5 Jun 2018

how to make matlab output the full number in digits, and not in exponential form?


Sign in to comment.

6 Answers

Answer by Oleg Komarov on 6 Aug 2011
 Accepted Answer

format long




i have tried this but its not showing the complete value. i have tried below:


format long



Output : 4451685225093714900000000000000000

but the correct output should be 4451685225093714772084598273548427

Is there any other method to get the complete value?

You can't exactly represent that number in double precision floating point. When you call the eps function with a numeric input, it returns the distance to the next largest floating-point number. In your case:

>> format longg
>> eps(4451685225093714772084598273548427)
ans =

So representable numbers are widely spaced when you get to that large a magnitude, and there's no guarantee that the particular number you want is one of the representable numbers. See the picture on the first page of this Cleve's Corner article, but imagine if the numbers on the X axis were MUCH larger and the red lines MUCH more widely spaced.

So how could you do this? Use Symbolic Math Toolbox and be very careful to use symbolic arithmetic, not double precision arithmetic, when converting your string of hex digits into a symbolic value.

Sign in to comment.

Answer by Image Analyst
on 7 Aug 2011

"format long" won't do it. See my example. You can use fprintf() to print to the command window (again, see example), or sprintf() to save into a variable or display in the command window if (and save to "ans") if you don't assign a variable to the return value and leave off the semicolon.

fprintf('\nFirst, using format long...\n');
format long
m = rand(1,3)/1000
fprintf('\nNow, using fprintf()...\n');
fprintf('%.8f ', m)
fprintf('\n\nNow, using sprintf()...\n');
sprintf('%.8f ', m)

Results in the command window:

First, using format long...
m =
  1.0e-003 *
   0.549723608291140   0.917193663829810   0.285839018820374
Now, using fprintf()...
0.00054972 0.00091719 0.00028584 
Now, using sprintf()...
ans =
0.00054972 0.00091719 0.00028584 

I don't know of anyway to have it operate like you want by default without issuing a command like fprintf().


format long g

helps. However, integers that exceed 2^53 will be represented in scientific notation with "format long g". To get the full digits of those, you need to use sprintf() or fprintf()

Yes it can help. Sometimes some sneak through even with that (if there would be more than three 0's to the right of the decimal point), like this which I tried:

m =
Columns 1 through 4
0.000538342435260057 0.000996134716626886 7.81755287531837e-005 0.000442678269775446
Columns 5 through 8
0.000106652770180584 0.000961898080855054 4.63422413406744e-006 0.000774910464711502

Sign in to comment.

Answer by Walter Roberson
on 19 Feb 2018

For MS Windows and Linux, to get full number of digits and not in exponential form, you need to either use the Symbolic toolbox or you need to use a tool such as from the File Exchange. This is crucial for MS Windows, which does a rather poor job of converting exact values; Linux does a better job but still has inaccuracies after a while.

On Mac (OS-X, MacOS), the built in conversion is exact, and you can choose to sprintf() with a '%.1074f' format. For example,

>> sprintf('%.1074f', eps(realmin))
ans =

For larger values you might want to trim out trailing zeros from the converted string

val = pi*1E-200;
regexprep( sprintf('%.1074f', val), '0+$', '', 'lineanchors')
ans =


Sign in to comment.

Answer by Mark Bower on 20 Oct 2017
Edited by Mark Bower on 20 Oct 2017

A nice, consistent solution is to use "num2str()". The same call works for both display from the command line:

> val = 1234567890
val =
> num2str(val)
ans =

and also within print statements:

> sprintf(num2str(val))
ans =

It also works for floating point numbers:

> val = 123456.789  
val =  
> sprintf(num2str(val))  
ans =


>> num2str(pi*10^5)
ans =

This is not "full decimal places"

Using num2str() inside sprintf() is redundant.


The sprintf is totally superfluous, it does nothing useful at all here, just slows down the code. In any case, using a proper sprintf format string would be quicker than calling num2str, and provide more control over the number of digits, so why not do that?

Sign in to comment.

Answer by Huw S
on 31 Jan 2017

If you don't need to know all the decimal points, then do your equation inside round.

saves all the other bother of exponentials.

  1 Comment

Unfortunately not the case:

>> format short
>> round(2^54)
ans =
>> format long g
>> round(2^54)
ans =
>> uint64(2^54)
ans =

Sign in to comment.

Answer by Kaveh Vejdani on 19 Feb 2018

I don't understand why you have accepted the wrong answers. What you're looking for is: format short g

Cheers, Kaveh


>> format short g
>> pi*10^5
ans =

That does not appear to satisfy either part of the requirement,

"how to make matlab output the full number in digits, and not in exponential form?"

For any formatting, one can find a special case (an absurdly huge number or an infinitesimally small one) to make it fail. For "practical" purposes, long g and short g will do the job perfectly.

>> format short g
>> pi
ans =

This is not "full number in digits"

>> 1000000
ans =

this is not even close to being an "absurdly huge number"

format short g gives you at most 5 significant figures.

format long g gives you at most 15 significant figures. It turns out that is not enough in practice to be unique. There are 24 distinct representable values in unique(pi-37*eps:eps:pi+9*eps), all of which display as 3.14159265358979 under format long g. If the goal is to output enough digits to be able to transfer the values exactly in text form, then format long g is not sufficient.

People get caught by this all the time!

format long g
T = 0.3 - 0.2
T == 0.1
T - 0.1
T =
ans =
ans =

People have difficulty understanding why a value that shows up as 0.1 does not compare as equal to 0.1: the limits of format long g have real effects.

Sign in to comment.