Fundamental Data Types
All data in MATLAB is in the form of a
matrix or array. But the data that we use in MATLAB software are of different
classes. We can make matrices and arrays of any types of these data classes. Two
of the MATLAB classes, structures and cell arrays, provide a way to store
dissimilar types of data in the same array. There are 15 fundamental data classes
in MATLAB. We can develop our own data types. Different data types require
different amounts of storage space, the smallest type is ‘logical’, which
requires only 1 byte.
(Picture courtesy: www.mathworks.com)
By default, MATLAB stores all numeric variables as doubleprecision
floatingpoint values and text as characters.
Numeric Data Types
Numeric data types are mainly of two types: FloatingPoint
Numbers and Integers. Floating point numbers are again two types:
Double – This
is the default numeric data type. It uses double precision. It can be created
by simple assignment operator. ‘double( )’ command is used to convert other data
types to double class.
Single – Any
value stored as a single requires 32 bits. ‘single( )’ command is used to
convert the double type data to single data type. Requires less storage space
than double.
‘isfloat( )’ command is used to verify that a
variable is a floatingpoint number. It returns logical 1 if the number is a
floatingpoint number and logical 0 otherwise.
Example:
>> a=25.456
a =
25.4560
>> whos
Name Size Bytes Class
Attributes
a 1x1 8 double
>> b=single(a)
b =
25.4560
>> whos b
Name Size Bytes Class
Attributes
b 1x1 4 single
Note:
The range for double is:
1.79769e+308
to 2.22507e308 and
2.22507e308 to 1.79769e+308
The range for single is:
3.40282e+38
to 1.17549e38 and
1.17549e38 to
3.40282e+38
Integer – This
class is used to represent the signed and unsigned whole numbers. Based on the
size used (1, 2, 4 and 8 bytes), there are four types of signed and unsigned classes.
Class

Range of Values

Conversion Function

Signed 8bit integer

2^{7} to 2^{7}1

int8

Signed 16bit integer

2^{15} to 2^{15}1

int16

Signed 32bit integer

2^{31} to 2^{31}1

int32

Signed 64bit integer

2^{63} to 2^{63}1

int64

Unsigned 8bit integer

0 to 2^{8}1

uint8

Unsigned 16bit integer

0 to 2^{16}1

uint16

Unsigned 32bit integer

0 to 2^{32}1

uint32

Unsigned 64bit integer

0 to 2^{64}1

uint64

Example:
>> c=int16(25.450)
c =
25
>> d=uint16(25.450)
d =
0
>> e=int64(25.450)
e =
25
>> whos
Name Size Bytes Class
Attributes
c 1x1 2 int16
d 1x1 2 uint16
e 1x1 8 int64
>> x='Electrical'
x =
Electrical
>> y=int32(x) % int
command can be used to convert other data types to integers.
y =
69 108 101 99 116 114 105 99 97 108
Characters
MATALB store the text as character data type. Strings
are represented as vectors of characters. MATLAB identifies the characters in single quotation marks as text
and such variables are saved as character data class.
‘char( )’ command is used to convert to character
array. Convert the integers between 32–127 into a the printable ASCII
characters.
‘ischar( )’ is used to Determine whether item is
character array
>> x='Electrical';
>> whos x
Name Size Bytes Class
Attributes
x 1x10 20 char
Considering the variable y from the previous example,
we can convert it back to text using:
>> z=char(y)
z =
Electrical
Logical
The logical data type is used to store Boolean values,
true or false states using the numbers 1 and 0, respectively. Output of some MATLAB
functions or operators will be logical values, those variables are stored as
logical data class.
‘logical( )’  Convert numeric values to logical. Any
nonzero element of A is converted to logical 1 (true) and zeros are converted
to logical 0 (false).
‘islogical( )’  Determine if input is logical array
Tables
This data type is used to store the tables which have
multiple columns of different data types. Tables consist of rows and
columnoriented variables. Each variable in a table can have a different data
type and a different size with the one restriction that each variable must have
the same number of rows. The data may be stored or in a text file or in a
spreadsheet.
Create table from workspace variables


Convert homogeneous array to table


Convert cell array to table


Convert structure array to table


Convert table to homogeneous array


Convert table to cell array


Convert table to structure array


Create table from file


Write table to file

Working with tables will be discussed in detail in
another post.
Structures
Structure is a data type used to store information like
a database. It groups related data using data containers called fields. Each
field can contain data of any type or size. Access data in a structure using
dot notation of the form structName.fieldName.
a =
struct(field1 ,value1, field2 ,value2,…. ) is the syntax of command to create
a structure with the specified field and values. The argument field is the name of the field and the value input argument can be any data
type, such as a numeric, logical, character, or cell array.
Example:
>> field1 = 'voltage';
>> field2 = 'current';
>> value1 = [10, 20, 30];
>> value2 = [1, 2, 3];
>> vi = struct(field1, value1, field2, value2)
vi =
voltage: [10 20 30]
current: [1 2 3]
>> vi.voltage
ans =
10 20
30
>> vi.current
ans =
1 2
3
>> vi.resistance = 10
vi =
voltage: [10 20 30]
current: [1 2 3]
resistance: 10
Cell Array
A cell array is a data type with indexed data
containers called cells, where each cell can contain any type of data. Cell
arrays commonly contain either lists of text strings, combinations of text and
numbers, or numeric arrays of different sizes.
An empty cell can be created using ‘cell( )’ command
>> C = cell(3,4)
C =
[ ] [ ]
[ ] [ ]
[ ] [ ]
[ ] [ ]
[ ] [ ]
[ ] [ ]
A curly bracket{} operator can use the to create an
empty 0by0 cell
>> C = {}
C =
{}
>> D={[1 2 3]; 'text value'}
D =
[1x3 double]
'text value'
Refer to sets of cells by enclosing indices in smooth
parentheses, (). Access the contents of cells by indexing with curly braces,
{}.
Function Handles
Function handles are the data type used to store
variables that index to a function. Function handle used to construct anonymous
functions or specify call back functions or call local functions from outside
the main function.
To create a handle for a function, precede the
function name with an @ sign.
>> magnitude = @abs;
>> magnitude(3+4i)
ans =
5