Lesson 10: Other Kinds of Arrays

The default data type for complex number is double. A double array needs 8 bytes to store it. A complex number requires 16-bytes storage room, because both the real and imaginary components must be stored. If convert complex numbers to int8, it needs 2 byte (16-bit) memory size.

>> F = 8 - 2i
F =  8.0000 - 2.0000i
>> class(F)
ans = 'double'
>> x = whos('F');
>> x.size
ans =  16
>> G = int8(F)
G =   8 - 2i
>> class(G)
ans =  'int8'
>> y = whos('G');
>> y.size
y =  2

Single-precision floating-point numbers use only half the storage space of a double-precision number and thus store only half the information. Each value requires only 4 bytes, or 4 × 8 = 32 bits, of storage space. Since single-precision numbers are allocated only half as much storage space, they cannot cover as large a range of values as double-precision numbers. It will make round-off error when you calculate very small values.

Consider the following series: \(\sum {\left( {\frac{1}{1} + \frac{1}{2} + \frac{1}{3} + \frac{1}{4} + \cdots + \frac{1}{n} + \cdots } \right)} \)

A series is the sum of a sequence of numbers, and this particular series is called the harmonic series , represented with the following shorthand notation:

\(\sum\limits_{n = 1}^\infty {\frac{1}{n}} \)

The harmonic series diverges; that is, it just keeps getting bigger as you add more terms together. You can represent the first 10 terms of the harmonic sequence with the following commands:

% Change the format to rational
format rat
n = 1:10;
harmonic = 1./n

harmonic =  1  1/2  1/3  1/4  1/5  1/6  1/7  1/8  1/9  1/10

Or you can use the short format, which shows decimal representations of the numbers:

format short
harmonic

harmonic =  1.0000  0.5000  0.3333  0.2500  0.2000
            0.1667  0.1429  0.1250  0.1111  0.1000

By default, the data are stored as double-double precision floating-point numbers inside the computer. By calculating the partial sums (also called cumulative sums), we can see how the value of the sum of these numbers changes as we add more terms:

partialSum = cumsum(harmonic)

partialSum =
    1.0000   1.5000   1.8333   2.0833   2.2833
    2.4500   2.5929   2.7179   2.8290   2.9290

The cumulative sum (cumsum) function calculates the sum of the values in the array up to the element number displayed.

The only problem with this process is that the values in harmonic keep getting smaller and smaller. Eventually, when n is big enough, 1./n is so small that the computer can't distinguish it from zero. This happens when the number system does not have enough space to store the value.

Convert an int8 value to uint8.

% Define a scalar 8-bit integer.
a = int8(5);
% Convert a to an unsigned 8-bit integer.
b = cast(a, 'uint8');
class(b)

In the Command Window, you will see:

ans =  'uint8'

Converts between data types of the same size

>> typecast(uint8(255), 'int8')
ans =  uint8   -1
>> typecast(int16(-1), 'uint16')
ans =  uint16  65535

Set X to a 1×3 vector of 32-bit integers, then cast it to an 8-bit integer type:

>> X = uint32([1 255 256])
X =  1  255  256

Running this on a little-endian system produces the following results. Each 32-bit value is divided up into four 8-bit segments

>> Y = typecast(X, 'uint8')
Y =  1  0  0  0  255  0  0  0  0  1  0  0

The third element of X, 256, exceeds the 8 bits that it is being converted to in Y(9) and thus overflows to Y(10):

>> Y(9:12)
ans =  0  1  0  0

Note that length(Y) is equal to 4.*length(X). Also note the difference between the output of typecast versus that of cast:

>> Z = cast(X, 'uint8')
Z =  1  255  255

This example casts a smaller data type (uint8) into a larger one (uint16). Displaying the numbers in hexadecimal format makes it easier to see just how the data is being rearranged:

>> format hex
>> X = uint8([44 55 66 77])
X =  2c 37 42 4d

The first typecast is done on a big-endian system. The four 8-bit segments of the input data are combined to produce two 16-bit segments

>> Y = typecast(X, 'uint16')
Y =  2c37  424d

The second is done on a little-endian system. Note the difference in byte ordering:

>> Y = typecast(X, 'uint16')
Y =  372c  4d42

You can format the little-endian output into big-endian (and vice versa) using the swapbytes function:

>> Y = swapbytes(typecast(X, 'uint16'))
Y =  2c37  424d

This example attempts to make a 32-bit value from a vector of three 8-bit values. MATLAB issues an error because there are an insufficient number of bytes in the input:

>> format hex
>> typecast(uint8([120 86 52]), 'uint32')
Error using typecast
Too few input values to make output type.

Repeat the example, but with a vector of four 8-bit values, and it returns the expected answer:

>> typecast(uint8([120 86 52 18]), 'uint32')
ans =  12345678

Convert multiple character arrays into two padded character arrays, C, D.

A1 = 'Apple';
A2 = 'IBM';
A3 = 'CalStateLA';
C = char(A1, A2, A3)
D = [char(A1, A2)]

C =  3×10 char array
    'Apple     '
    'IBM       '
    'CalStateLA'
D =  2×5 char array
    'Apple'
    'IBM  '

A two-dimensional character arrays can be created only if the number of elements in each row is the same. Thus, a list of names such as the following won't work, because each name has a different number of characters:

>> A = ['Vicky';'Ryan';'Kevin';'David';'Michael']
??? Error using ==> vertcat
All rows in the bracketed expression must have the same number of columns.

The char function "pads" a character array with spaces, so that every row has the same number of elements:

>> A = char('Vicky','Ryan','Kevin','David','Michael')
A = 5×7 char array
    'Vicky  '
    'Ryan   '
    'Kevin  '
    'David  '
    'Michael'

A is 5×7 character array. Notice that commas are used between each string in the char function.

You can use string function to create a string array.

>> B = string({'Vicky';'Ryan';'Kevin';'David';'Michael'})
B =  5×1 string array
    "Vicky"
    "Ryan"
    "Kevin"
    "David"
    "Michael"

The resulting string is a 5×1 string array. Each name is stored as a string element in the array. Notice the double quotes used to indicate a string, versus the single quotes used to indicate a character array.

You can create a string by enclosing a piece of text in double quotes.

>> str = "Hello, world"
str =  "Hello, world"

Another way to create a string array is to concatenate strings into an array using square brackets ([]), just as you can concatenate numbers into a numeric array.

>> str = ["Mercury","Gemini","Apollo";
          "Skylab","Skylab B","ISS"]
str = 2x3 string array
    "Mercury"   "Gemini"      "Apollo"
    "Skylab"    "Skylab B"    "ISS"

The array score contains test scores for the students in the character array student. If we try to combine these two arrays, we will get a strange result, because they are two different data types. The MATLAB will convert the score array to characters.

>> score = [84; 100; 88; 95; 100];
>> student_c = char('Vicky','Ryan','Kevin','David','Michael');
>> results = [student_c, score]
results = 5×8 char array
    'Vicky  T'
    'Ryan   d'
    'Kevin  X'
    'David  _'
    'Michaeld'

When doubles and characters are used in the same array, MATLAB converts all the information to characters.

The num2str function is used to convert the double score matrix to a matrix composed of character data. 

>> score_c = num2str(score)
score_c =  5×3 char array
    ' 84'
    '100'
    ' 88'
    ' 95'
    '100'

Now, we can combine student_c, the character array of names, with score_c, the character array of scores. The disp function also can be used to display the results:

>> results = [student_c, score_c]
results = 5×10 char array
    'Vicky 84'
    'Ryan 100'
    'Kevin 88'
    'David 95'
    'Michael100'
>> disp([student_c, score_c])
Vicky 84
Ryan 100
Kevin 88
David 95
Michael100

Or, you can use the fprintf function in combination with a for loop to display the results:

for i=1:length(score)
    fprintf(' %10s %8.0f \n', student_c(i,:), score(i))
end

returns

Vicky          84
Ryan          100
Kevin          88
David          95
Michael       100

When we create a string array of the combined student and score data type by simple concatenating the two arrays:

>> score = [84; 100; 88; 95; 100];
>> student_s = string({'Vicky';'Ryan';'Kevin';'David';'Michael'});
>> R = [student_s, score]
R =  5×2 string array
    "Vicky"      "84"
    "Ryan"       "100"
    "Kevin"      "88"
    "David"      "95"
    "Michael"    "100"

The result is a 5×2 string array. Notice that the numbers have been converted to strings automatically. We can use fprintf to display the result:

>> fprintf('  %10s  %10s \n', R')
      Vicky          84
       Ryan         100
      Kevin          88
      David          95
    Michael         100

To find the unique words in a string, split it on space characters and call the unique function.

First, create a string scalar.

>> str = "A horse! A horse! My kingdom for a horse!";

Remove the exclamation point.

>> str = erase(str,"!")
str =  "A horse A horse My kingdom for a horse"

Convert all letters in str to lowercase characters.

>> str = lower(str)
str =  "a horse a horse my kingdom for a horse"

Split str on space characters using the split function. split discards the space characters and returns the result as a string array.

>> str = split(str)
str = 9x1 string array
    "a"
    "horse"
    "a"
    "horse"
    "my"
    "kingdom"
    "for"
    "a"
    "horse"

Find the unique words in str using the unique function.

>> str = unique(str)
str = 5x1 string array
    "a"
    "for"
    "horse"
    "kingdom"
    "my"

>> A = 'Four score and seven years ago'
A =  'Four score and seven years ago'
>> str = string(A)
str =  "Four score and seven years ago"

str contains the same characters as A. But while A is a character vector, str is a string scalar.

>> c = size(A)
c = 1×2
    1   30
>> s = size(str)
s = 1×2
    1   1

To return the number of characters in str, use the strlength function.

>> n = strlength(str)
n =  30

Convert a cell array of character vectors to a string array.

>> A = {'Mercury','Gemini','Apollo';...
        'Skylab','Skylab B','ISS'}
A = 2x3 cell array
    {'Mercury'}  {'Gemini' }   {'Apollo'}
    {'Skylab' }  {'Skylab B'}  {'ISS' }
>> str = sting(A)
str = 2x3 string array
    "Mercury"   "Gemini"     "Apollo"
    "Skylab"    "Skylab B"   "ISS"

To access the second element in the first row of str, index using smooth parentheses. You can access strings in a string array with matrix indexing, just as you would access elements of a numeric array.

>> str(1,2)
ans =  "Gemini"

Access the third column.

>> str(:, 3)
ans = 2x1 string array
    "Apollo"
    "ISS"

>> A = [77 65 84 76 65 66];
>> str = string(A)
str = 1x6 string array
    "77" "65" "84" "76" "65" "66"

str is a string array in which each element represents a number from A. Note that string does not treat numbers as ASCII or Unicode values the way that the char function does.

Create a string array in which each element represents a number. To convert the string array to a numeric array, use the double function.

>> str = ["256","3.1416","8.9e-3"]
>> X = double(str)
X = 1×3
    256.0000   3.1416   0.0089

When the input argument is a string array, the double function treats each element as the representation of a floating-point value. However, when the input is a character array, double instead converts each character to a number representing its Unicode value.

As an alternative, use the str2double function. str2double is suitable when the input argument might be a string array, character vector, or cell array of character vectors.

>> Y = str2double(str)
Y = 1×3
    256.0000   3.1416   0.0089
>> C = '2.7183';
>> Z = str2double(C)
Z =  2.7183

Create a duration array, D. Then convert D to a string array.

>> D = hours(23:25) + minutes(8) + seconds(1.2345);
>> str = string(D)
str = 1x3 string array
    "23.134 hr"   "24.134 hr"   "25.134 hr"

str is a string array with one duration value per element. str is the same size as D.

Specify the format of the duration values in str.

>> str = string(D,'hh:mm')
str = 1x3 string array
    "23:08"   "24:08"   "25:08"

Create a 10,000×10,000 full storage identity matrix.

>> A = eye(10000);
>> whos A
  Name       Size            Bytes  Class    Attributes
  A      10000x10000     800000000  double

Each element (double) needs 8-bytes storage room, This matrix uses 800-megabytes of memory.

Convert the matrix to sparse storage.

>> S = sparse(A);
>> whos S
  Name       Size            Bytes  Class    Attributes
  S      10000x10000        240008  double   sparse

In sparse form, the same matrix uses roughly 0.25-megabytes of memory. In this case, you can avoid full storage completely by using the speye function, which creates sparse identity matrices directly.

>> S = sparse(10000,5000)
S =   All zero sparse: 10000×5000

Create a categorical array, A.

>> A = categorical({'plane' 'car' 'train' 'car' 'plane'})
A = 1×5 categorical array
    plane    car    train    car    plane

A is a 1×5 categorical array.

Display the categories of A.

>> C = categories(A)
C = 3×1 cell array
    {'car'  }
    {'plane'}
    {'train'}

Since you created A by specifying only an input array, the categories appear in alphabetical order.

Create an ordinal categorical array.

>> A = categorical({'medium' 'large'; 'small' 'xlarge'; 'large' 'medium'},...
                   {'small' 'medium' 'large' 'xlarge'},'Ordinal',true)
A = 3×2 categorical array
    medium   large
    small    xlarge
    large    medium

A is a 3×2 ordinal categorical array.

Display the categories of A.

>> C = categories(A)
C = 4×1 cell array
    {'small' }
    {'medium'}
    {'large' }
    {'xlarge'}

The categories appear in the order in which you specified them. Since A is ordinal, the categories have the mathematical ordering small < medium < large < xlarge.

Specify the current date and time in the local system time zone.

>> t = datetime('now','TimeZone','local','Format','d-MMM-y HH:mm:ss Z')
t =  datetime
    22-Oct-2019 00:37:24 -0700

Specify the current date and time in the time zone represented by Taipei, Taiwan.

>> t = datetime('now','TimeZone','Asia/Taipei','Format','d-MMM-y HH:mm:ss Z')
t =  datetime
    22-Oct-2019 15:37:24 +0800

Create a datetime array from a cell array of character vectors.

>> DateStrings = {'2014-05-26';'2014-08-03'};
>> t = datetime(DateStrings,'InputFormat','yyyy-MM-dd')
t = 2×1 datetime array
    26-May-2014
    03-Aug-2014

The datetime values in t display using the default format, and not the format of the input dates.

You can create string arrays with the string function and convert them to datetime values. Convert the strings, specifying the input format as yyyy-MM-dd. The format must be specified as a character vector, even though str is a string array.

>> str = string({'2016-03-24','2016-04-19'});
>> t = datetime(str,'InputFormat','yyyy-MM-dd')
t = 1×2 datetime array
    24-Mar-2016 19-Apr-2016

Create a datetime value from text that represents a date and time to millisecond precision. To convert text in a format that the datetime function cannot parse without more information, specify the 'InputFormat' name-value pair argument.

>> d = '2018-06-25 11:23:37.712';
>> t = datetime(d,'InputFormat','yyyy-MM-dd HH:mm:ss.SSS')
t = datetime
    25-Jun-2018 11:23:37

The conversion does keep the fractional seconds. However, by default datetime arrays do not display fractional seconds. To display them, specify either the 'Format' name-value pair or the Format property.

>> t.Format = 'MMM dd, yyyy HH:mm:ss.SSS'
t = datetime
    Jun 25, 2018 11:23:37.712

The 'InputFormat' argument applies only to conversions from input text. The Format property specifies the display for any datetime array.

Create a datetime array from individual arrays of year, month, and day values.

Create sample numeric arrays of year values Y and day values D. In this case, the month value M is a scalar.

>> Y = [2014;2013;2012];
>> M = 01;
>> D = [31;30;31];

Create the datetime array.

>> t = datetime(Y,M,D)
t = 3×1 datetime array
    31-Jan-2014
    30-Jan-2013
    31-Jan-2012

Specify a custom display format for the output, using the Format name-value pair argument.

>> t = datetime(Y,M,D,'Format','eeee, MMMM d, y')
t = 3×1 datetime array
    Friday, January 31, 2014
    Wednesday, January 30, 2013
    Tuesday, January 31, 2012

Consider the following different arrays:

X = 1:3;
Y = ['abcdefg'];
Z = single([1, 2, 3; 4, 5, 6]);

These arrays are all of a different data type and size. X is a double, Y is a char, and Z is a single. We can combine them into one cell array by using curly brackets ({}) as cell-array constructor (the standard array constructors are square brackets,[])

>> C = {X, Y, Z}
C =  1×3 cell array
    {1×3 double}   {'abcdefg'}   {2×3 single}

Create a cell array that contains several temperature readings taken on a given date. Specify a date as a character vector, and temperatures as an array of doubles. To store these pieces of data in a cell array, enclose them in curly braces.

>> C = {'2019-10-20', [56 67 78]}
C = 1x2 cell array
    {'2017-08-16'}   {1x3 double}

Add readings for different dates to the cell array. One way to add more cells is to expand the cell array by assignment, just as you can expand an ordinary array.

>> C(2,:) = {'2019-10-21',[58 69 79]};
>> C(3,:) = {'2019-10-22',[60 68 81]};
>> C
C = 3x2 cell array
    {'2019-10-20'}   {1x3 double}
    {'2019-10-21'}   {1x3 double}
    {'2019-10-22'}   {1x3 double}

Index into the first row of C. When you index with smooth parentheses, (), the result is a cell array that is a subset of the cell array.

>> C(1,:)
ans = 1x2 cell array
    {'2019-10-20'}   {1x3 double}

Index into the contents of a cell. When you index with curly braces, {}, the result is the piece of data that is contained in the specified cell.

>> C{1,2}
ans = 1×3
    56   67   78

Create a cell array.

>> C = {'row1',[1 2 3],3+4i;
        'row2',[2 4;1 3],{'innercells',42}}
C = 2x3 cell array
    {'row1'}   {1x3 double}   {[3.0000 + 4.0000i]}
    {'row2'}   {2x2 double}   {1x2 cell }

Display the contents of each cell using the celldisp function. celldisp also displays the curly-brace indexing you can use to index into cells.

>> celldisp(C)
C{1,1} =  row1
C{2,1} =  row2
C{1,2} =  1  2  3
C{2,2} =
    2   4
    1   3
C{1,3} =   3.0000 + 4.0000i
C{2,3}{1} =  innercells
C{2,3}{2} =  42

The last cell contains a cell array. celldisp also displays the contents of each cell from the inner cell array.

Call celldisp and specify a cell array as its first input argument. Since the first argument is not a workspace variable, and so does not have a name of its own, specify a name as the second argument. celldisp displays the cell array using this name.

>> celldisp({'row1',5,10},'myCells')
myCells{1} =   row1
myCells{2} =   5
myCells{3} =   10

Call celldisp without specifying a name. When there is no variable name or second input argument, celldisp displays ans as the name of the cell array.

>> celldisp({'row1',5,10})
ans{1} =   row1
ans{2} =   5
ans{3} =   10

Consider the following different arrays:

X = 1:3;
Y = ['abcdefg'];
Z = single([1, 2, 3; 4, 5, 6]);

Store related pieces of data in the fields of a structure. You can give the fields human-readable names that describe the data. Here, we can create a simple structure by adding fields to it using dot notation.

data.numbers = X

which returns

data =  struct with fields:
    numbers: [1 2 3]

The name of the structure array is data. It has one field, called numbers. We can now add the content in the character matrix Y to a second field called letters:

data.letters = Y

data =  struct with fields:
    numbers: [1 2 3]
    letters: 'abcdefg'

Finally, we add the single-precision numbers in matrix Z to a third field called more_numbers:

data.more_numbers = Z

data =  struct with fields:
         numbers: [1 2 3]
         letters: 'abcdefg'
    more_numbers: [2×3 single]

Notice in the Workspace window that the structure matrix (called a struct) is a 1×1 array that contains all the information from all three dissimilar matrices.

We can add more content to the structure, and expand its size, by adding more matrices to the fields we’ve defined:

data(2).numbers = [1 3 5 7]

data =  1×2 struct array with fields:
    numbers
    letters
    more_numbers

You can access the information in structure arrays by using the matrix name, field name, and index numbers. The syntax is similar to what we have used for other types of matrices. An example is

data(2)

ans = struct with fields:
         numbers: [1 3 5 7]
         letters: []
    more_numbers: []

To access just a single field, add the field name:

data(1).numbers

ans =  1  2  3

To access the content of a particular element in a field, add the index number after the field name:

data(1).numbers(2)

ans =  2

The disp function also can be used to display the contents of structure arrays. For example:

disp(data(1).numbers(2))

returns

2

Structure arrays are of limited use in engineering calculations , but they are widely used in large computer programs to pass information between functions.

Create a structure by adding fields to it using dot notation. The fields contain x- and y-values for a sine wave, and text that describes the data.

data.x = linspace(0,2*pi);
data.y = sin(data.x);
data.title = 'y = sin(x)'

data =  struct with fields:
        x: [1×100 double]
        y: [1×100 double]
    title: 'y = sin(x)'

Plot the sine wave. You can refer to the arrays of x- and y-values by their field names. Then add the title.

plot(data.x,data.y)
title(data.title)