Numeric types (double, single, integer) in MATLAB

Introduction

Numeric types tell MATLAB how to store and use numbers. They help save memory and control precision.

When you want to save memory by using smaller number types.

When you need more precise decimal numbers for calculations.

When working with whole numbers and want faster operations.

When interfacing with hardware or files that require specific number formats.

Syntax

MATLAB

% Create variables with different numeric types
A = double(3.14);
B = single(3.14);
C = int32(10);

double is the default numeric type in MATLAB.

Use functions like double(), single(), or int32() to convert values.

Examples

This creates a double precision number, a single precision number, and a 16-bit integer.

MATLAB

x = double(5.5);
y = single(5.5);
z = int16(5);

Here, int8 stores signed 8-bit integers, and uint8 stores unsigned 8-bit integers.

MATLAB

a = int8(-100);
b = uint8(200);

Shows how single precision stores fewer decimal places than double.

MATLAB

val = single(1.23456789);
disp(val);

Sample Program

This program creates variables of different numeric types and prints their types. It also shows how double and single precision differ in decimal accuracy.

MATLAB

% Sample program showing numeric types
A = 10; % default double
B = single(10); % single precision
C = int32(10); % 32-bit integer

fprintf('A is type: %s\n', class(A));
fprintf('B is type: %s\n', class(B));
fprintf('C is type: %s\n', class(C));

% Show difference in precision
x_double = 1.123456789012345;
x_single = single(x_double);

fprintf('Double precision: %.15f\n', x_double);
fprintf('Single precision: %.15f\n', x_single);

Important Notes

Double precision uses 64 bits and is MATLAB's default for numbers.

Single precision uses 32 bits and saves memory but has less accuracy.

Integer types store whole numbers and come in different sizes like int8, int16, int32, and uint8, uint16, etc.

Summary

Numeric types control how MATLAB stores numbers in memory.

Double is default and most precise; single uses less memory but less precise.

Integer types store whole numbers and are useful for specific needs like memory saving or hardware interfacing.