1. Numeric Arrays
Numeric Data Types in MATLAB

single
,double
: singleprecision floatingpoint values (32 bits) and doubleprecision floatingpoint values (64 bits) 
int8
,int16
,int32
,int64
: #bit signed integers 
uint8
,uint16
,uint32
,uint64
: #bit unsigned integers 
NaN
,Inf
Fortran Ordering and Array Indexing
MATLAB uses Fortran (columnwise) ordering of data.

It is contrary to C/C++ (rowwise), in which if we store a
m*n
twodimensional matrix as a linear array, we should dimensionalize it by ourself, such as usingi*m+j
to indexing. 
First dimension is the fastest varying dimension, which means we first vary rows, then columns. For example, if we store 11, 12, …, 18 in a
2*2*2
threedimensional array:>> M = reshape(11:18, [2,2,2]) M(:, :, 1) = 11 13 12 14 M(:, :, 2) = 15 17 16 18

This Fortran ordering and linear storage allow us to index into array with single index or a vector of indices (this is how the array is really stored in memory). In above example, we can assume
M
is a vector of size 8, even thoughM
is a threedimensional array. For example:% linear indexing (scalar) >> M(1) ans = 11 >> M(8) ans = 18 % linear indexing (vector) >> M(5:8) ans = 15 16 17 18 >> M([1, 3, 4, 8]) ans = 11 13 14 18
The vectors of indices we give determines the shape of the output. In above code, since we are giving linear vectors, our output is going to be a vector as well.

If we have indices inputed as matrix, then this means we want our output to be a matrix as well (of same size as the index matrix):
% linear indexing (matrix) >> M([1, 5, 2; 8, 3, 2; 7, 4, 6]) ans = 11 15 12 18 13 12 17 14 16

We can also access the elements using component form:
% component indexing (matrix) >> M([1, 2], [2, 1], [2, 1]) ans(:, :, 1) = 17 15 18 16 ans(:, :, 2) = 13 11 14 12
Component indexing is more common than linear because it is more straightforward, but the linear indexing option is always there since this is how the array is really stored in memory.

Componentwise indexing with matrices is equivalent to componentwise indexing with vectorization of matrix (first varying row dimension, then column dimension):
>> M([1, 2; 1, 2], [2, 1], 1) ans = 13 11 13 11 14 12 14 12 >> M([1, 1, 2, 2], [2, 1], 1) ans = 13 11 13 11 14 12 14 12
Reshaping Arrays

reshape(X, [m, n, p, ...])
: reshapeX
into sizem*n*p*...
(overall dimension must be the same as the original)>> N = rand(100,1); >> size(reshape(N, [50, 2])) ans = 50 2 >> size(reshape(N, [25, 2, 2])) ans = 25 2 2

repmat(X, [m, n, p, ...])
: repeatX
along dimensionsm*n*p*...
(stack the pattern vertically or horizontally)>> size(repmat(N, [4, 3])) ans = 400 3 >> size(reshape(N, [4, 3, 2])) ans = 400 3 2

fliplr(X)
: flip matrix in left/right direction 
flipud(X)
: flip matrix in up/down direction 
squeeze(X)
: remove singleton dimensions (remove a dimension which is 1)>> A = [1, 2; 3, 4]; >> A(:, :, 2) = [5, 6; 7, 8]; >> size(A(:, :, 1)) ans = 2 2 % note the difference caused by Fortran ordering >> size(A(1, :, :)) ans = 1 2 2 >> size(squeeze(A(1, :, :))) ans = 2 2
2. Cells and Cell Arrays
Cell Array Creation and Indexing

Cell array is very useful in certain applications when we need to store a variety of different data types.

Cell array is a collection of data of any MATLAB type. It allows us to store not only numerical, but also characters, strings, etc.

This flexibility sacrifices storage efficiency. The inbetween cells within a cell array are not stored contiguously in memory. Each cell is contiguous, but not two cells next to each other.

A cell array is constructed with
{}
orcell
. Each cell array is a MATLAB array of cell, which can be mixed data types. 
Indexing

Cell containers indexed using
()
:c(i)
returnsi
th cell of cell arrayc
. This cannot be used to modify elements. Instead, we may uset = c(i)
andt{1}
to access the content. 
Cell contents indexed using
{}
:c{i}
returns contents ofi
th cell of cell arrayc
% for loop in cell array >> c = {14, [1, 2; 5, 6], 'hello world'}; >> for t = c, class(t), end ans = 'cell' ans = 'cell' ans = 'cell' >> for t = c, t{1}, end ans = 14 ans = 1 2 5 6 ans = 'hello world'


cellplot(c)
provides a handy feature to help us visualize our data in cell arrayc
.
Add and Delete Data

We know that create/access cell array entry requires using
{}
. 
To assign contents of container, we use
=
as usual. 
To delete cell from cell array, we should grab cell containers with
()
and then assign the value[]
to it. Note: assigning elements with{}
and set them to[]
does not delete cell entries. It will only clear the data in that cell.>> A = {}; >> A{1, 1} = 'up left diagonal entry'; A{2, 2} = 'bottom right diagonal entry' A = 'up left diagonal entry' [] [] 'bottom right diagonal entry' >> A{1, 1} = [] % does not delete cell A = [] [] [] 'bottom right diagonal entry' >> A(1, :) = [] % delete cells in the first row A = [] 'bottom right diagonal entry'
Memory Requirements

Cell arrays require additional memory to store information describing each cell, which are stored in a header and label it as a
double
,character
,string
, etc. This means we have some memory required for header of each single cell.>> c = {[]}; s = whos('c'); s.bytes ans = 112 % 112 bytes required just for the header, even it is empty

Memory required for whole cell array:
(head_size * number_of_cells) + data

Contents of a single cell stored contiguously

Storage not necessarily contiguous between cells in array
CommaSeparated Lists via Cell Arrays

We can construct a list of MATLAB objects separated by commas and each item displayed individually when printed.

This is useful in passing arguments to functions (e.g., plotting) and assigning output variables.
>> plotStyle = {'bo−', 'linewidth', 2, 'markerfacecolor', 'r'}; >> plot(1:10, plotStyle{:}) % Pass comma−separated list to function