Numeric Types and Floating Point

By default MATLAB stores every number as a double-precision floating-point value, and you cannot change that default. x = 3 is a double. To store a value in another class you convert it with the class name used as a function: single(x), int8(x), uint16(x).

class(x) returns the name of the class as text; isa(x,"numeric"), isa(x,"integer") and isa(x,"float") test for a class or a family of classes; isnumeric, isfloat and isinteger do the same for the three families. Note that isnumeric(true) is false and isinteger(5) is false, because 5 is a double. All numeric classes support indexing, reshaping and the usual mathematical functions (with the exceptions described below); integer and single arrays use less memory than double ones.

The limits of each class are returned by functions, so you never type the constants:

Octave 11.3.0 output:

Source: MATLAB documentation: Numeric Types, MATLAB documentation: Integers, MATLAB documentation: intmax, MATLAB documentation: realmax

double and single follow IEEE Standard 754 and use the rounding mode "round to nearest, ties to even". A floating-point number has the form (-1)^s * (1 + f) * 2^e, with a sign bit s, a fraction f (0 or more and less than 1) and an exponent e. A double spends 64 bits on this: 1 for the sign (bit 63), 11 for the exponent, biased by 1023 (bits 62 to 52), and 52 for the fraction (bits 51 to 0). A single spends 32: 1, 8 (bias 127) and 23.

Because only a finite set of numbers exists, most real numbers are rounded, and the distance between neighbours is not constant: it is eps(x), and it doubles each time x passes a power of two. The figure shows the gap growing from 2^-52 on [1, 2) to 2^-49 on [8, 16). Three consequences matter in practice:

flintmax is 2^53 for double and 2^24 for single. Above it only every second integer (then every fourth, and so on) can be stored, so converting a large integer to a floating-point class can change it. flintmax is smaller than the largest value of an integer class of the same width (2^53 against 2^64 - 1 for int64), so an int64 value above 2^53 converted with double loses accuracy.

Octave 11.3.0 output:

fprintf with enough digits shows the stored value of 0.1 (0.1000000000000000055…​), and why ten additions of 0.1 do not make exactly 1. sprintf("%.17g",x) gives the same text as a value, which is the way to see all the digits of a number whatever the display format.

Source: MATLAB documentation: Floating-Point Numbers

== on floating-point values tests exact equality, so values that are equal mathematically often differ in the last bits (the first line of the session above). Compare with a tolerance:

TF = isapprox(A,B) (since R2024b) applies a combined test, with default relative and absolute tolerances of 1e-15 (5e-7 if either input is single); isapprox(A,B,tol) takes the level "verytight", "tight", "loose" or "veryloose", and the name-value arguments RelativeTolerance and AbsoluteTolerance set the tolerances. NaN values are not approximately equal. isapprox is not run here (Octave 11.3.0 does not have it); for code that must run on an older release, write the explicit comparison. The details and an example are on Logical Type and Conditions.

Mixed-class comparison has a trap of its own. When one operand is single, the other is converted to single before the comparison, so a value that is not exactly representable in single can compare equal to its rounded copy:

Octave 11.3.0 output:

The single value nearest 0.1 is 0.10000000149011612 as a double, so the second line (comparison made in single) is true and the third (made in double) is false. The last line shows flintmax("single") at work: 16777216 plus 1 is rounded back to 16777216.

Source: MATLAB documentation: Floating-Point Numbers, MATLAB documentation: isapprox

MATLAB has four signed and four unsigned integer classes, with 1, 2, 4 or 8 bytes of storage. Three rules define their arithmetic.

Conversion rounds to the nearest integer and saturates. A fractional value is rounded to the nearest integer, and a fraction of exactly one half is rounded to the integer larger in magnitude (int8(2.5) is 3 and int8(-2.5) is -3). A value outside the range becomes the nearest end of the range: int8(300) is 127, uint8(-5) is 0. NaN converts to 0 and Inf to the largest value. To use another rounding, apply round, fix, floor or ceil first.

Arithmetic saturates too. An integer result that is out of range does not wrap around; it stops at intmin or intmax of the class. int8(100) + int8(100) is 127 and uint8(5) - uint8(10) is 0. The documentation’s integer-arithmetic example uses this to find where a summed 8-bit signal saturates by comparing it with intmin and intmax.

The class of the operands decides the class of the result. Two integers of the same class give that class; an integer and a scalar double give the integer class (the documentation describes this for scalar doubles). The exact result is computed (in double precision, or as if in extended precision for a 64-bit integer array with a scalar double) and then rounded and saturated to the integer class. Two different integer classes cannot be combined arithmetically, and complex numbers are not supported with integer classes.

Octave 11.3.0 output (a few lines are shortened to the value):

The error text for mixed integer classes is Octave’s; MATLAB raises an error for the same expression, with its own wording and identifier (not run here).

Integer division with / rounds the exact quotient to the nearest integer (int8(7)/int8(2) is 4). C = idivide(A,B,opt) divides integers with the rounding of your choice: opt is "fix" (the default, toward zero), "floor", "ceil" or "round". At least one operand must be an integer class, and with a scalar double operand the integer operand cannot be int64 or uint64.

Source: MATLAB documentation: Integers, MATLAB documentation: Integer Arithmetic, MATLAB documentation: idivide

For concatenation the documentation states that when integers are combined with double, single or logical data, all elements take the class of the leftmost integer. The result is therefore an integer even when a double comes first, and the converted values are rounded and saturated. The last row of the table is the surprise: ['a' 66] is the text aB.

Octave 11.3.0 output:

Source: MATLAB documentation: Numeric Types, MATLAB documentation: Floating-Point Numbers

single(x) halves the memory of a double array, and zeros(n,1,"single") and ones(n,1,"single") create single arrays directly. Operations on single data are computed in single precision, and the result of single with double is single. single has about 7 decimal digits, so eps(single(1)) is 1.1921e-07 and flintmax("single") is 16777216; use it for large arrays where that accuracy is enough, or when a library or hardware wants it, not as a default.

Octave 11.3.0 output (the whos layout differs in MATLAB; the sizes are the point):

The heatflow time-step limit dt <= dx^2/(4*alpha) evaluates to about 0.2273 in either class; the two agree to about 8 digits. For the temperature matrix of a large plate, single halves the 8 MB of the double field to 4 MB, at the cost of that precision.

Source: MATLAB documentation: Single Precision Math

The imaginary unit is written i or j (the numeric constants, valid as a suffix: 3+4i), or 1i and 1j, which are safe even if a variable named i exists (see Syntax, Statements and Variables). complex(a,b) builds a + bi from two real inputs, and is the only way to make a complex value with a zero imaginary part, or one of an integer class, since an expression such as 3+0i is simplified to the real 3. For x real, complex(x) is x + 0i with isreal false.

Octave 11.3.0 output:

Octave shows complex values with a space after the equals sign and no rounding to four decimals when the parts are integers; MATLAB’s layout differs (it shows z = 3.0000 + 4.0000i for non-integer data), but the values agree. roots([1 0 1]), the roots of x^2 + 1, are the pair 0 + 1i and 0 - 1i. Operations on complex numbers are done in floating-point arithmetic: exp(1i*pi) is not exactly -1 but has an imaginary part of about 1.2246e-16.

Source: MATLAB documentation: Create Complex Numbers, MATLAB documentation: complex

Inf is the IEEE positive infinity, produced by division by a zero, overflow and log(0) (which is -Inf); -Inf is the negative one. NaN ("not a number") is produced by operations with no defined result: 0/0, Inf - Inf, Inf*0. The functions Inf and NaN also create arrays (NaN(3), Inf(2,"single"), NaN(2,3)), and isinf, isnan and isfinite test arrays. A number above realmax overflows to Inf, and below realmin the value becomes subnormal and loses digits until it underflows to 0.

NaN propagates: any arithmetic with a NaN yields NaN, so one missing reading spoils a sum or mean. Every comparison with NaN is false except ~=; NaN == NaN is false, and the way to test is isnan(x), never x == NaN. isequal(NaN,NaN) is false and isequaln(NaN,NaN) is true. max and min skip NaN values.

Octave 11.3.0 output:

The thermocouple log of the heatflow scenario has deliberate gaps, which come in as NaN: mean(Tm) is NaN, while mean(Tm,"omitnan") averages the four readings that exist. Handling missing data, including NaN in tables, is on Missing Data. Converting NaN to an integer class gives 0, which hides the gap; convert only after removing or flagging the missing values.

Source: MATLAB documentation: Infinity and NaN, MATLAB documentation: NaN

Octave 11.3.0 output:

The byte pattern 0 0 128 63 is little-endian for 1.0 in single, which is why the last typecast returns 1 on a little-endian machine.

Source: MATLAB documentation: cast, MATLAB documentation: typecast, MATLAB documentation: class

The display format changes how numbers are shown, not how they are stored. The default format short shows 5 significant digits (3.1416). format(style) or the command form format style sets the style for the session; the preferences under Settings, Command Window, Numeric format set it for later sessions. fmt = format returns the current format.

The table summarizes the documentation. format long is the quickest way to see that a value is not what you typed, and format hex shows the bit pattern (the same one typecast exposes). A matrix with a wide range of magnitudes is shown with a common scale factor or in scientific notation. format alone restores short. Use disp, fprintf, sprintf or compose when the output layout must be exact (see Strings and Character Arrays).

Octave 11.3.0 output (MATLAB shows x under format long in scientific notation, 3.141592653589793e+03, so the layouts differ):

Source: MATLAB documentation: Display Format for Numeric Values, MATLAB documentation: format

The older books treat double as the only number type, introduce int8 to uint64 and single briefly, and often show results of integer arithmetic without the rule that mixed integer classes are an error. They predate several functions on this page: isapprox (R2024b) for comparison with a tolerance, the like= syntax of typecast (R2024b), and the "omitnan" option of the statistics functions. They use i and j freely as the imaginary unit even though loops use them as variable names. The floating-point rules themselves (IEEE 754, eps, realmax) have not changed.