MATLAB Desktop Fundamentals

# 2.1 Fundamental Data Types

The fundamental data types in MATLAB include numeric types, character types, and logical types.

### 2.1.1 Numeric Types

Numeric types are used to represent numbers, including integers, real numbers, and complex numbers. Integer types include int8, int16, int32, and int64, representing signed integers of 8, 16, 32, and 64 bits respectively. Real number types include single and double, representing 32-bit and 64-bit floating-point numbers respectively. The complex type represents complex numbers composed of a real part and an imaginary part.

# 2. MATLAB Data Types and Variables

### 2.1 Fundamental Data Types

MATLAB supports a variety of fundamental data types to represent different types of numeric and character data.

#### 2.1.1 Numeric Types

***double:** Double-precision floating-point numbers used to represent real numbers with a precision of 15-16 decimal places.
***single:** Single-precision floating-point numbers used to represent real numbers with a precision of 7-8 decimal places.
***int8, int16, int32, int64:** Signed integers occupying 8, 16, 32, and 64 bits respectively.
***uint8, uint16, uint32, uint64:** Unsigned integers occupying 8, 16, 32, and 64 bits respectively.

#### 2.1.2 Character Types

***char:** A single character denoted by single quotes.
***string:** A string denoted by double quotes.

#### 2.1.3 Logical Type

***logical:** Logical values representing true or false denoted by true and false respectively.

### 2.2 Variable Operations

#### 2.2.1 Variable Definition and Assignment

Variables in MATLAB are referenced by variable names, which must start with a letter and may contain letters, numbers, and underscores. Variable definition uses the assignment operator `=`, as shown below:

a = 10; % Define variable a and assign the value 10

#### 2.2.2 Variable Type Conversion

MATLAB provides various functions for converting variable types, some common ones are:

***double(x):** Converts x to a double-precision floating-point number.
***single(x):** Converts x to a single-precision floating-point number.
***int8(x):** Converts x to an 8-bit signed integer.
***char(x):** Converts x to a character.

#### 2.2.3 Variable Scope

Variable scope in MATLAB is divided into the workspace and function scope. Workspace variables are valid throughout the entire MATLAB session, whereas function scope variables are only valid within the function.

**Code Block:**

% Workspace variable
a = 10;

% Function scope variable
function myFunction()
     b = 20;
end

**Logical Analysis:**

* Variable `a` is defined in the workspace and can be used throughout the entire MATLAB session.
* Variable `b` is defined within the function `myFunction` and is only valid inside the function.

**Parameter Description:**

* `a`: Workspace variable, type double.
* `b`: Function scope variable, type double.

# 3.1 Matrix Operations

#### 3.1.1 Matrix Creation and Initialization

In MATLAB, a matrix is a two-dimensional array composed of rows and columns. There are several methods to create a matrix:

***Creating a matrix using square brackets []:**

A = [1, 2, 3; 4, 5, 6; 7, 8, 9];

***Creating a matrix using built-in functions zeros() and ones():**

B = zeros(3, 3); % Creates a 3x3 zero matrix
C = ones(3, 3);   % Creates a 3x3 identity matrix

***Creating a matrix using the colon operator :**

D = 1:10;    % Creates a row vector from 1 to 10
E = 1:3:10;  % Creates a row vector from 1 to 10 with a step of 3

#### 3.1.2 Matrix Operations and Functions

MATLAB offers a rich set of matrix operations and functions, including:

***Arithmetic operations:** Addition (+), subtraction (-), multiplication (*), division (/)
***Logical operations:** AND (&), OR (|), NOT (~)
***Comparison operations:** Equal (==), not equal (~=), greater than (>), less than (<)
***Matrix functions:** Determinant (det), inverse matrix (inv), transpose (transpose)

**Example:**

A = [1, 2, 3; 4, 5, 6; 7, 8, 9];
B = [10, 11, 12; 13, 14, 15; 16, 17, 18];

% Matrix addition
C = A + B;

% Matrix multiplication
D = A * B;

% Matrix determinant
detA = det(A);

#### 3.1.3 Matrix Indexing and Slicing

MATLAB allows the use of indexing and slicing to access elements within a matrix. Indexing starts at 1, and slicing uses the colon : operator to specify a range.

***Indexing:**

A = [1, 2, 3; 4, 5, 6; 7, 8, 9];

% Accessing an element in the matrix
element = A(2, 3); % Gets the element in the second row and third column

***Slicing:**

A = [1, 2, 3; 4, 5, 6; 7, 8, 9];

% Getting the second row of the matrix
row2 = A(2, :);

% Getting the first column of the matrix
column1 = A(:, 1);

**Mermaid Flowchart:**

graph LR
subgraph Matrix Creation and Initialization
     A[Create Matrix] --> B[Square Brackets []]
     A[Create Matrix] --> C[zeros() and ones()]
     A[Create Matrix] --> D[Colon Operator :]
end

subgraph Matrix Operations and Functions
     A[Matrix Operations] --> B[Arithmetic Operations]
     A[Matrix Operations] --> C[Logical Operations]
     A[Matrix Operations] --> D[Comparison Operations]
     A[Matrix Operations] --> E[Matrix Functions]
end

subgraph Matrix Indexing and Slicing
     A[Matrix Indexing] --> B[Indexes]
     A[Matrix Indexing] --> C[Slicing]
end

# 4. MATLAB Flow Control

### 4.1 Conditional Statements

Conditional statements are used to execute different blocks of code based on specific conditions. MATLAB provides two common conditional statements: the if-else statement and the switch-case statement.

#### 4.1.1 if-else Statement

The if-else statement is used to execute different blocks of code based on one or more conditions. Its syntax is as follows:

if condition
     % Code block 1
else
     % Code block 2
end

Here, `condition` is a Boolean expression. If it is true, code block 1 is executed; otherwise, code block 2 is executed.

**Example:**

x = 5;
if x > 0
     disp('x is positive')
else
     disp('x is non-positive')
end

**Output:**

x is positive

#### 4.1.2 switch-case Statement

The switch-case statement is used to execute different blocks of code based on the value of a variable. Its syntax is as follows:

switch variable
     case value1
         % Code block 1
     case value2
         % Code block 2
     ...
     otherwise
         % Default code block
end

Here, `variable` is the variable to be compared, and `value1`, `value2`, etc., are the values compared with `variable`. If the value of `variable` matches one of the `case` values, the corresponding code block is executed. If there is no matching `case`, the `otherwise` code block is executed.

**Example:**

grade = 'A';
switch grade
     case 'A'
         disp('Excellent')
     case 'B'
         disp('Good')
     case 'C'
         disp('Pass')
     otherwise
         disp('Fail')
end

**Output:**

Excellent

### 4.2 Loop Statements

Loop statements are used to repeatedly execute a block of code. MATLAB provides three common loop statements: the for loop, the while loop, and the break and continue statements.

#### 4.2.1 for Loop

The for loop is used to execute a block of code for a series of values. Its syntax is as follows:

for variable = start:increment:end
     % Code block
end

Here, `variable` is the loop variable, `start` is the starting value of the loop, `increment` is the value by which the loop variable is incremented each time, and `end` is the ending value of the loop.

**Example:**

for i = 1:10
     disp(i)
end

**Output:**

*
*
*
*
*
*
*
*
*
**

#### 4.2.2 while Loop

The while loop is used to execute a block of code as long as a condition is true. Its syntax is as follows:

while condition
     % Code block
end

Here, `condition` is a Boolean expression. If it is true, the code block is executed.

**Example:**

i = 1;
while i <= 10
     disp(i)
     i = i + 1;
end

**Output:**

*
*
*
*
*
*
*
*
*
**

#### 4.2.3 break and continue Statements

The break statement is used to exit a loop, while the continue statement is used to skip the current iteration and continue with the next one.

**Example:**

for i = 1:10
     if i == 5
         break
     end
     disp(i)
end

**Output:**

1
2
3
4

# 5.1 Function Definition and Invocation

### 5.1.1 Function Syntax

MATLAB functions are defined using the `function` keyword, with the following syntax:

function [output_args] = function_name(input_args)
     % Function body
end

Where:

* `function_name`: The name of the function, which must start with a letter and cannot conflict with MATLAB reserved words.
* `input_args`: Function input arguments, which can be multiple and separated by commas.
* `output_args`: Function output arguments, which can be multiple and enclosed in square brackets.
* `Function body`: The specific implementation code of the function.

### 5.1.2 Function Parameter Passing

There are two ways to pass function parameters:

***Value Passing:** A copy of the parameter value is passed to the function; changes made to the parameter inside the function do not affect variables outside the function.
***Reference Passing:** The address of the parameter is passed to the function; changes made to the parameter inside the function affect variables outside the function.

By default, MATLAB uses value passing, but reference passing can be implemented using the `global` keyword.

### 5.1.3 Function Return Values

A function can return multiple values using the `return` statement, with the following syntax:

return [output_arg1, output_arg2, ..., output_argn]

If a function does not explicitly specify return values, it defaults to returning `[]`.