1
2
3
4
5
6
7
8
9
10
11
12
13
% Single line comment
%{
Multi-line comment
using block comment syntax
%}

% Print statement
disp('Hello, World!');

% Suppress output with semicolon
x = 5 + 3;  % Calculation without display
disp(x);    % Explicit display

1
2
3
4
5
6
7
8
9
10
11
12
13
% Numeric Types
integer_val = int32(42);    % 32-bit integer
float_val = 3.14159;        % Double-precision floating point
complex_val = 2 + 3i;       % Complex number (1i / 1j are also valid)

% Logical Type
is_true = true;
is_false = false;

% Character and String
char_val = 'A';             % Single character (char array)
string_val = "Hello World"; % String scalar (recommended for text data)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
% Arrays (Fundamental in MATLAB)
% Numeric Arrays
numbers = [1, 2, 3, 4, 5];           % Row vector
column_vector = [1; 2; 3; 4; 5];      % Column vector

% Matrix
matrix = [1 2 3; 4 5 6; 7 8 9];       % 3x3 matrix

% Cell Arrays (Mixed-type container)
cell_array = {42, 'text', [1 2 3]};

% Struct Arrays
person = struct('name', 'John', 'age', 30, 'city', 'New York');

% Tables (recommended for tabular/mixed-type data)
T = table(["Alice"; "Bob"], [30; 25], 'VariableNames', {'Name','Age'});

% Dictionaries (introduced in R2022b)
d = dictionary(["apple","banana"], [1, 2]);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
% Variable naming (case-sensitive)
user_name = 'JohnDoe';
totalCount = 100;

% Constants (using uppercase convention; MATLAB has no true const keyword)
PI = pi;            % Built-in constant
GRAVITY = 9.81;

% Multiple assignment
[a, b, c] = deal(1, 2, 3);

% Workspace management
who        % List current variables
whos       % Detailed variable information
clear x    % Remove specific variable

1
2
3
4
5
6
7
8
9
% Basic arithmetic
a = 10; b = 3;
add_result = a + b;     % Addition
sub_result = a - b;     % Subtraction
mult_result = a * b;    % Multiplication
div_result = a / b;     % Division
power_result = a ^ b;   % Exponentiation
mod_result = mod(a, b); % Modulus

1
2
3
4
5
6
7
8
9
% Comparison returns logical array
x = [1, 2, 3, 4, 5];
y = [5, 4, 3, 2, 1];

equal = x == y;         % Element-wise equality
not_equal = x ~= y;     % Element-wise inequality
greater = x > y;        % Element-wise greater than
less_equal = x <= y;    % Element-wise less or equal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
% Logical operations
a = true;
b = false;

and_result = a & b;     % Element-wise AND
or_result = a | b;      % Element-wise OR
not_result = ~a;        % Logical NOT
short_and = a && b;     % Short-circuit AND (scalars)
short_or  = a || b;     % Short-circuit OR  (scalars)

% Logical indexing
numbers = [1, 2, 3, 4, 5];
even_numbers = numbers(mod(numbers, 2) == 0);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
% If-ElseIf-Else
score = 85;

if score >= 90
    grade = 'A';
elseif score >= 80
    grade = 'B';
elseif score >= 70
    grade = 'C';
else
    grade = 'F';
end

% MATLAB has no ternary (?:) operator. Common replacements:
result = "Fail";
if score >= 60, result = "Pass"; end

% Or using a helper / element-wise selection:
result_vec = ["Fail" "Pass"]( (score >= 60) + 1 );

% Switch
switch grade
    case {'A','B'}
        disp('Great');
    case 'C'
        disp('OK');
    otherwise
        disp('Needs work');
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
% For Loop
for i = 1:5
    disp(i);
end

% While Loop
count = 0;
while count < 5
    count = count + 1;
    disp(count);
end

% Break and Continue
for j = 1:10
    if j == 3
        continue;  % Skip iteration
    end
    if j == 7
        break;     % Exit loop
    end
    disp(j);
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
% Basic function
function result = add(x, y)
    result = x + y;
end

% Anonymous Functions
square = @(x) x.^2;

% Multiple Return Values
function [sum_val, avg_val] = compute_stats(numbers)
    sum_val = sum(numbers);
    avg_val = mean(numbers);
end

% Function Handles
func_handle = @sin;
result = func_handle(pi/2);

% Argument Validation (R2019b+)
function y = scale(x, factor)
    arguments
        x        (1,:) double
        factor   (1,1) double = 1.0
    end
    y = x * factor;
end

% Name-Value arguments (R2021a+)
function plotIt(x, y, opts)
    arguments
        x, y
        opts.Color  string = "blue"
        opts.Width  double = 1.5
    end
    plot(x, y, 'Color', opts.Color, 'LineWidth', opts.Width);
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
% Matrix Creation
A = [1 2 3; 4 5 6; 7 8 9];
B = zeros(3, 3);        % Zero matrix
C = ones(2, 4);         % Matrix of ones
D = rand(3, 3);         % Random matrix

% Matrix Arithmetic
matrix_sum = A + B;
matrix_product = A * B;
element_wise_mult = A .* B;  % Dot operator for element-wise operations

% Matrix Transformations
transpose_A = A';       % Complex-conjugate transpose
plain_T    = A.';       % Plain (non-conjugate) transpose
inverse_A  = inv(A);    % Matrix inverse (prefer A\b for solving Ax=b)
determinant = det(A);

% Solving linear systems (preferred over inv)
b = [1; 2; 3];
x = A \ b;              % Backslash operator

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
% Class Definition
classdef Rectangle
    properties
        Length
        Width
    end
    
    methods
        function obj = Rectangle(l, w)
            obj.Length = l;
            obj.Width = w;
        end
        
        function area = getArea(obj)
            area = obj.Length * obj.Width;
        end
    end
end

% Usage
rect = Rectangle(5, 3);
area = rect.getArea();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
% Try-Catch Block
try
    result = 10 / 0;     % Note: returns Inf, not an error in MATLAB
catch ME
    disp('Error occurred');
    disp(ME.identifier);
    disp(ME.message);
end

% Custom Error with identifier
function r = safeDivide(a, b)
    if b == 0
        error('safeDivide:divideByZero', 'Cannot divide by zero');
    end
    r = a / b;
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
% Text File I/O
% Write
fileID = fopen('output.txt', 'w');
fprintf(fileID, 'Hello, MATLAB\n');
fclose(fileID);

% Read
fileID = fopen('input.txt', 'r');
data = textscan(fileID, '%s');
fclose(fileID);

% MAT File (MATLAB's native format)
save('data.mat', 'variable1', 'variable2');
load('data.mat');

% CSV / spreadsheet (modern functions; csvread/csvwrite/xlsread are not recommended)
M = readmatrix('data.csv');           % Numeric matrix
writematrix(M, 'output.csv');

T = readtable('data.csv');            % Table with mixed types and headers
writetable(T, 'output.csv');

% Timetables for time-stamped data
TT = readtimetable('data.csv');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
% Basic Plotting
x = linspace(0, 2*pi, 100);
y = sin(x);

% Line Plot
plot(x, y, 'r-', 'LineWidth', 2);
title('Sine Wave');
xlabel('x');
ylabel('sin(x)');

% Multiple Plots with tiledlayout (preferred over subplot since R2019b)
figure;
tiledlayout(2,1);
nexttile; plot(x, sin(x)); title('sin');
nexttile; plot(x, cos(x)); title('cos');

% 3D Plotting
[X, Y] = meshgrid(-5:0.5:5);
Z = X.^2 + Y.^2;
surf(X, Y, Z);

% Export graphics (preferred over print/saveas for figures)
exportgraphics(gcf, 'figure.png', 'Resolution', 300);

1
2
3
4
5
6
7
8
9
10
11
% Simulink basics typically involve graphical modeling
% Requires Simulink toolbox

% Script to create and simulate a simple model
new_system('mymodel');
open_system('mymodel');
add_block('simulink/Sources/Sine Wave', 'mymodel/Sine Wave');
add_block('simulink/Sinks/Scope',       'mymodel/Scope');
add_line('mymodel', 'Sine Wave/1', 'Scope/1');
sim('mymodel');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
% Check installed toolboxes
ver                 % List installed toolboxes

% Example: Signal Processing Toolbox
Fs = 1000;          % Sampling frequency
t = 0:1/Fs:1;       % Time vector
x = sin(2*pi*50*t) + 0.5*randn(size(t));
filtered_x = lowpass(x, 100, Fs);

% Image Processing
img = imread('image.jpg');
gray_img = rgb2gray(img);
edge_img = edge(gray_img, 'Sobel');

% Deep Learning Toolbox (modern API)
net = imagePretrainedNetwork("resnet50");   % R2024a+ unified loader
% (older "resnet50" / "alexnet" standalone functions are deprecated in favor of
%  imagePretrainedNetwork)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
% Parallel Computing Toolbox features
% Create parallel pool (auto-starts on first parfor in most setups)
pool = parpool;          % Default process-based pool
% pool = parpool("Threads"); % Thread-based pool (lower overhead, since R2020a)

% Parallel for loop
results = zeros(1, 1000);
parfor i = 1:1000
    results(i) = some_computation(i);
end

% GPU arrays (requires Parallel Computing Toolbox + supported GPU)
A = gpuArray(rand(1000));
B = A * A';              % Runs on GPU
C = gather(B);           % Bring back to CPU memory

% Close pool when done
delete(pool);

1
2
3
4
5
6
7
8
9
10
11
12
% Call Python from MATLAB
py.list({1, 2, 3});
np = py.importlib.import_module('numpy');
arr = np.array([1, 2, 3]);

% Call MATLAB from Python (via the matlabengine package)
% pip install matlabengine

% Call C/C++ via MEX or the C++ Interface
% Call REST APIs
data = webread("https://api.example.com/data.json");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
% Vectorization over loops
% Slow
for i = 1:length(data)
    result(i) = sin(data(i)) + 1;
end

% Fast (true vectorization — built-ins are already element-wise)
result = sin(data) + 1;

% Preallocate arrays
result = zeros(1, 1000);  % Preallocate before loop

% Prefer string arrays over char arrays for text data
names = ["Alice", "Bob", "Carol"];

% Prefer tables/timetables over parallel arrays for mixed data

% Use the arguments block for input validation in functions

% Use local functions and packages (+folders) to organize code

% Profile before optimizing
profile on
% ... code ...
profile viewer