U20CBT715

IT WORKSHOP SCILAB /
MATLAB
UNIT IV
INTRODUCTION TO PROGRAMMING
Contents
• Introduction
• M-File Scripts
• Script Side-Effects,
• M-File Functions,
• Anatomy of a M-File Function,
• Input and Output arguments,
• Input to a Script File,
• Output Commands
Introduction to MATLAB
Programming
Aim :
• To explore the essential components of MATLAB

programming, focusing on M-File scripts and functions that

form the backbone of efficient MATLAB code.

• How to create, structure, and optimize your MATLAB

DD
programs through practical examples and best practices

• Ready to develop your own efficient code.

Introduction to Programming in
MATLAB
M-File Scripts
Execute a sequence of MATLAB statements saved in a .m file. Variables are
added to the workspace.

M-File Functions
Accept input arguments and return output arguments, with their own isolated
workspace.

Input Command
Use input to prompt the user for variable values during script execution.

Output Commands
disp for simple output, fprintf for more control over display and writing to files.

MATLAB allows you to write and run programs using M-files. Scripts are useful for
automating command sequences, while functions are ideal for extending MATLAB's
language with reusable routines. Understanding control flow structures like if, for, and
while statements is crucial for building complex programs.
What is MATLAB Programming?
Definition Key Features Applications

MATLAB (Matrix Laboratory) is a high- • Matrix-based language • Data analysis

level programming language and • Built-in graphics for visualization • Algorithm development
interactive environment specifically
• Extensive mathematical function library • Scientific research
designed for numerical computation,
• Support for various programming • Engineering solutions
visualization, and application
paradigms
development.
MATLAB Programming
Environment
Command Window
The primary interface for entering commands and viewing results interactively.
Commands are executed immediately after pressing Enter.

Editor
A dedicated environment for creating and modifying M-files (scripts and
functions). Features syntax highlighting, debugging tools, and code analysis.

Workspace
Displays all variables currently in memory, allowing you to inspect and
manipulate data during program execution.

Figure Window
Displays graphical output including plots, images, and visualizations generated
by your MATLAB code.
Introduction to M-Files

What are M-Files? Types of M-Files File Management

Text files containing Two main types: scripts M-files must be saved
MATLAB code with a .m (sequence of in a directory on the
extension, serving as commands) and MATLAB path to be
the primary way to functions (reusable accessible. The current
store and execute code blocks with inputs directory is searched
MATLAB programs. and outputs). first.
Understanding M-File Scripts
What Are M-File Scripts? Execution Process
Text files containing a sequence of MATLAB Scripts run in the current workspace, using
statements, saved with a .m extension. They existing variables and creating new ones that
allow for executing multiple commands with a persist after execution completes.
single call.

Creating Scripts Organizing Code

Use the MATLAB Editor to create and modify Scripts help organize sequences of commands
scripts, with options for syntax highlighting, error into reusable files, improving code maintainability
checking, and debugging tools. and documentation.

M-file scripts serve as the foundation for automating repetitive tasks in MATLAB. They provide a way to save and
execute sequences of commands without having to retype them in the command window, significantly enhancing
your productivity.
M-File Scripts: Overview
Automation
Automate complex or repetitive tasks

Reusability
Save sequences of commands for future use

Organization
Group related commands in a single file

M-File scripts are the simplest form of MATLAB programming, allowing you to store a sequence of MATLAB commands in a file that
can be executed repeatedly. Unlike functions, scripts operate directly in the workspace, accessing and modifying existing variables
without requiring explicit input or output arguments.
Creating Your First M-File Script
Open the MATLAB Editor
Click on "New Script" in the Home tab or use the keyboard shortcut Ctrl+N
(Windows) or Cmd+N (Mac).

Write Your Code

Enter a sequence of MATLAB commands that you want to execute. For
example, a simple calculation or data visualization.

Save the File

Save the file with a descriptive name and the .m extension in a
directory on the MATLAB path.

Run the Script

Execute the script by typing its name (without the .m extension) in
the Command Window or by clicking the "Run" button in the Editor.
Example of a Simple M-File Script
Script Code Execution

When you run this script by typing myFirstScript in the

% myFirstScript.m% A simple script to calculate
Command Window, MATLAB executes each command
the area of a circle% Define the radiusradius =
sequentially.
5;% Calculate the areaarea = pi * radius^2;% The output will be:
Display the resultdisp('The area of the circle
is:');disp(area); The area of the circle is:78.5398

All variables created (radius and area) remain in the workspace

after execution.
Script Comments and
Documentation
Comment Types
• Single-line comments using % symbol
• Block comments using %{ and %} for multiple lines

Header Comments
Best practice includes adding a header with script name, description, author,
date, and usage information at the top of each script.

Inline Comments
Add comments next to complex code to explain the purpose or logic of specific
operations.

Section Breaks
Use %% to create code sections that can be executed independently in the Editor.
Script Side-Effects: Managing Workspace Impact
Global Workspace Changes
Scripts modify the main workspace directly

Variable Overwriting
Existing variables can be unintentionally modified

Memory Utilization
All variables remain in memory after execution

Output Persistence
Results remain available for further analysis

When a script executes, it operates directly in the MATLAB workspace, which creates both benefits and challenges. This direct interaction means
that scripts can modify existing variables and create new ones that persist after the script completes.

Understanding these side-effects is crucial for writing robust code. Always be mindful of variable naming to avoid accidentally overwriting
important data. Consider using the "clear" command at the beginning of scripts when appropriate, or implement variable name prefixes to
reduce conflicts.
Script Side-Effects: Workspace Interaction
Reading from Workspace
Scripts can access and use any variables already defined in the workspace.

Modifying Existing Variables

Scripts can change the values of existing workspace variables.

Creating New Variables

Any variables created within a script are added to the workspace and remain after execution.

Clearing Variables
Scripts can remove variables from the workspace using clear commands.
Script Side-Effects: Potential Issues
Unpredictable Behavior
Hard-to-Debug Issues
Script behavior may change
depending on the current Side-effects can cause subtle
state of the workspace. bugs that are difficult to trace.
Name Conflicts
Dependency Problems
Scripts may unintentionally
overwrite existing variables Scripts may rely on variables
with the same names. that don't exist, causing
errors.
Best Practices for Managing
Script Side-Effects
Clear Workspace at Start
Begin scripts with clear or clear variables to ensure a clean workspace,
but be cautious as this affects all variables.

Check Variable Existence

Use exist('varName', 'var') to check if a variable exists before using it or
potentially overwriting it.

Use Distinctive Variable Names

Adopt a naming convention that makes script variables easily
identifiable and less likely to conflict with existing ones.

Document Dependencies
Clearly document any workspace variables that the script expects to
exist or will modify.
Script Example: Managing Side-Effects
Poor Practice Better Practice

% Calculate arearadius = 5;area = pi * % Calculate area% Check if radius existsif

radius^2;disp(area); ~exist('radius', 'var') radius = 5; % Default
valueend% Store original valueorig_radius = radius;
% Calculate with local copyradius_calc =
radius;area = pi * radius_calc^2;disp(area);%
This script assumes radius doesn't exist or can be overwritten, Restore original valueradius = orig_radius;
and leaves both variables in the workspace.
Introduction to M-File Functions
Modular Code
Break complex problems into manageable pieces

Reusable Components
Create code that can be used in multiple projects

Workspace Isolation
Protect the main workspace from unintended modifications

M-File functions are the cornerstone of effective MATLAB programming, enabling you to create reusable, modular code. Unlike
scripts, functions operate in their own workspace, accepting specific inputs and returning defined outputs, which makes them more
predictable and safer to use in complex programs.
M-File Functions: Encapsulating Code
Isolated Workspace Reusable Components Organization Benefits
Unlike scripts, functions operate Functions enable code reusability Functions help organize complex
in their own workspace, through parameterization. The algorithms into manageable,
preventing unwanted side- same function can process testable components. This
effects. Variables created inside different inputs without modular approach simplifies
a function remain local to that modification, making your code debugging and makes
function unless explicitly more versatile and maintainable. collaborative development more
returned. efficient.

M-file functions represent a significant advancement over scripts, offering better encapsulation and modularity. By
isolating variables to a local workspace, functions prevent the unintended side-effects common with scripts,
resulting in more predictable behavior and cleaner code.

Functions also enable more sophisticated program structures through their ability to accept inputs and return
specific outputs, making them ideal for creating reusable computational components.
Scripts vs. Functions: Key
Differences
Feature Scripts Functions

Workspace Operates in the base Has its own local

workspace workspace

Input Uses variables already Receives values

in workspace through input
arguments
Output Creates/modifies Returns specific values
variables in workspace through output
arguments

Side-effects Can modify any Changes limited to

workspace variable local workspace unless
global
File structure Simple sequence of Requires function
commands declaration and
specific syntax
Anatomy of an M-File Function
Function Declaration
First line defines function name, inputs, and outputs: function
[outputs] = functionName(inputs)

H1 Line & Help Text

First comment line (H1) provides a brief description, followed by
detailed help text

Function Body
Main code that processes inputs and computes outputs

Return Statement
Optional explicit return statement or implicit return at end of function

A well-structured function follows this anatomical pattern, beginning with a clear declaration line that establishes the
function's interface. The help text section is crucial for documentation, while the function body contains the actual
computational logic.
Function Declaration Syntax
Basic Syntax

function [output1, output2] = functionName(input1, input2, input3) % Function code hereend

Single Output
For functions with one output, brackets are optional:

function result = addNumbers(a, b) result = a + b;end

No Outputs
For functions that don't return values:

function displayMessage(message) disp(message);end

No Inputs
For functions that don't require inputs:

function result = getCurrentDate() result = date;end

Function Help Text and Documentation
H1 Line Help Text Structure Accessing Help

The first comment line after the function • Function purpose and description Users can view your documentation using:
declaration, which appears in search • Input argument details
results and function listings. help functionNamedoc
• Output argument details
functionName
• Examples of usage
function result =
• See also references to related functions
addNumbers(a, b)% ADDNUMBERS Well-documented functions are more
Sum of two numbers% Detailed likely to be used correctly and reused by
help text follows... others.
Example of a Well-Documented Function
function [area, circumference] = circleCalc(radius)% CIRCLECALC Calculate area and
circumference of a circle% [AREA, CIRCUMFERENCE] = CIRCLECALC(RADIUS) returns the area and
% circumference of a circle with the specified radius.%% Input:% RADIUS - Scalar
value representing the radius of the circle (must be positive)%% Outputs:% AREA -
The area of the circle (pi * radius^2)% CIRCUMFERENCE - The circumference of the
circle (2 * pi * radius)%% Example:% [a, c] = circleCalc(5)% % Returns: a =
78.5398, c = 31.4159%% See also: SPHERECALC, CYLINDERCALC% Input validationif radius <= 0
error('Radius must be a positive number');end% Calculate areaarea = pi * radius^2;%
Calculate circumferencecircumference = 2 * pi * radius;end
Input and Output Arguments
Input Arguments Output Arguments

• Can accept any number of parameters • Functions can return multiple values in separate variables
• Support variable types including matrices, • Must be assigned values before function completion
structures, and cell arrays • Common pattern: [y1, y2, ...] = functionName(x1, x2, ...)
• Default values can be set using nargin checks • Use varargout for variable-length output lists
• Use varargin for variable-length argument lists
MATLAB's ability to return multiple outputs in a single
Input arguments are passed by value, meaning function call is powerful, allowing complex calculations
functions receive copies of the original data. This to return various related results simultaneously.
prevents functions from modifying the original
variables unless they're explicitly returned.

Effective use of input and output arguments is essential for creating flexible, reusable functions. By properly
designing your function interfaces, you can create components that integrate seamlessly into larger systems and
workflows.
Function Input Arguments

Required Arguments Optional Arguments

Must be provided in the correct order Can be omitted, with the function using
when calling the function default values

Input Validation Variable Number of Arguments

Ensures inputs meet expected types, Allows functions to accept any number
sizes, and constraints of inputs using varargin
Required Input Arguments
Definition Best Practices

Required arguments must be provided when calling the • Keep required arguments to a minimum
function, in the exact order specified in the function • Place the most important arguments first
declaration.
• Group related parameters together
function result = multiply(a, b) result = a *
• Validate all required inputs
b;end
• Document expected types and dimensions

When calling this function, both arguments must be provided:

x = multiply(5, 3); % Correctx = multiply(5);

% Error
Optional Input Arguments
Check Argument Count
Use nargin (Number of Input Arguments) to determine how many arguments were provided.

Assign Default Values

Provide default values for arguments that weren't specified by the user.

Process Function Logic

Use the provided or default values in your function's main logic.

function result = powerFunc(base, exponent)% POWERFUNC Calculate base raised to

exponent% Optional second argument defaults to 2 (square)% Check if exponent
was providedif nargin < 2 exponent = 2; % Default to square if no exponent
givenend% Calculate resultresult = base ^ exponent;end
Variable Number of Input Arguments
Using varargin Mixed Required and Variable

The special parameter varargin allows a function to accept any You can combine required arguments with varargin:
number of additional arguments. It's a cell array containing all
extra arguments passed to the function. function plotData(x, y, varargin) % Required x
and y, optional formatting plot(x, y,
function result = sumAll(varargin) % Sum any varargin{:});end
number of input arguments result = 0; for i
= 1:nargin result = result + varargin{i};
endend This allows flexible calling:

plotData(x, y);plotData(x, y, 'r--', 'LineWidth',

2);
Input Argument Validation
Type Checking
Verify arguments are of the expected data type using functions like
isnumeric, ischar, iscell, or islogical.

Size Validation
Ensure arrays have the correct dimensions using size, length, or
numel functions.

Value Constraints
Check that values fall within acceptable ranges or meet specific criteria.

Error Handling
Use error or warning functions to provide clear messages when
validation fails.
Input Validation Example
function result = calculateSquareRoot(value)% CALCULATESQUAREROOT
Calculate the square root of a number% Validates that the input is a
numeric scalar and non-negative% Check if input is numericif
~isnumeric(value) error('Input must be numeric');end% Check if input
is a scalarif ~isscalar(value) error('Input must be a scalar
value');end% Check if input is non-negativeif value < 0 error('Input
must be non-negative');end% Calculate resultresult = sqrt(value);end
Function Output Arguments
Single Output Multiple Outputs Variable Outputs No Outputs
Functions that return Functions that return Functions that can Functions that perform
one value, the most several values as return different actions but don't return
common case. separate variables. numbers of outputs values.
depending on how
they're called.
Single Output Arguments
Declaration Assignment Usage

For a single output, you can use The output variable must be assigned a When calling the function, assign the
brackets or omit them: value within the function. result to a variable:

The variable name inside the function

function [result] = sum = addNumbers(5,
doesn't need to match the output name
addNumbers(a, b) result = a 3);disp(sum); % Displays: 8
in the declaration, but it's good practice
+ b;end% Or more
for clarity.
commonly:function result = Or use it directly in expressions:
addNumbers(a, b) result = a
+ b;end
disp(addNumbers(5, 3) * 2); %
Displays: 16
Multiple Output Arguments
Declare Multiple Outputs
List all output variables in square brackets in the function declaration.

Assign Values to All Outputs

Ensure each output variable is assigned a value within the function body.

Capture All Outputs When Calling

When calling the function, provide variables to capture all outputs in square brackets.

function [mean, stdev] = statsCalc(data)% STATSCALC Calculate mean and standard

deviation% Returns both statistics for the input datamean = sum(data) /
length(data);stdev = sqrt(sum((data - mean).^2) / length(data));end% Usage:data =
[4, 7, 2, 9, 3];[avg, std] = statsCalc(data);disp(['Mean: ', num2str(avg), ', Std
Dev: ', num2str(std)]);
Variable Number of Output Arguments
Using nargout Calling with Different Outputs

The nargout function returns the number of output arguments requested Users can request just what they need:
when the function was called.
% Just the meanavg = statsCalc(data);% Mean and median[avg,
function [mean, median, mode] = statsCalc(data)% Return med] = statsCalc(data);% All three statistics[avg, med, mod]
different statistics based on% how many outputs were = statsCalc(data);
requestedmean = sum(data) / length(data);if nargout > 1 %
Calculate median only if requested median =
median(data);endif nargout > 2 % Calculate mode only if
requested mode = mode(data);endend

This approach improves efficiency by only calculating what's needed.

No Output Arguments
Declaration Common Uses
Functions without outputs omit the output • Displaying information
section and equal sign: • Creating plots or visualizations
• Writing data to files
function displayStats(data) %
• Modifying global variables
Calculate and display statistics
% without returning any values
mean = sum(data) / length(data);
disp(['Mean: ', num2str(mean)]);
stdev = sqrt(sum((data -
mean).^2) / length(data));
disp(['Std Dev: ',
num2str(stdev)]);end

Calling
Call the function without assigning its result:

data = [4, 7, 2, 9, 3];displayStats(data);

Local Functions
Modular Design
Break complex functions into smaller components

Encapsulation
Hide implementation details from users

Single File Organization

Keep related functions together

Local functions are additional functions defined within the same M-file after the main function. They're only accessible to the main
function and other local functions in the same file, not to the outside world. This allows you to break down complex tasks into
smaller, more manageable pieces while keeping everything organized in a single file.
Local Functions Example
function result = analyzeData(data)% ANALYZEDATA Perform comprehensive data analysis% Main function that orchestrates the analysis process% Validate inputif ~isValidData(data) error('Invalid data format');end%
Preprocess the datacleanData = preprocessData(data);% Perform analysisresult = calculateStatistics(cleanData);end% Local function for validationfunction valid = isValidData(data) valid = isnumeric(data) &&
~isempty(data);end% Local function for preprocessingfunction clean = preprocessData(data) % Remove outliers and normalize clean = removeOutliers(data); clean = clean / max(abs(clean));end% Local function for
outlier removalfunction filtered = removeOutliers(data) mean_val = mean(data); std_val = std(data); filtered = data(abs(data - mean_val) <= 2*std_val);end% Local function for statisticsfunction stats =
calculateStatistics(data) [Link] = mean(data); [Link] = median(data); [Link] = std(data);end
Nested Functions
Definition
Functions defined entirely within another function, not after it

Variable Access
Can access and modify variables from the parent function's workspace

Scope
Only visible within the parent function, not outside it

Structure
Must end with their own 'end' statement before the parent function ends
Nested Functions Example
function result = calculateWithMemory(initialValue)% CALCULATEWITHMEMORY Function that remembers previous calculations% Demonstrates nested functions with shared variables% Variable in parent function
scopecurrentValue = initialValue;history = initialValue;% Return the nested function handleresult = @performCalculation; % Nested function that can access parent's variables function output =
performCalculation(operation, value) switch operation case 'add' currentValue = currentValue + value; case 'subtract' currentValue = currentValue - value;
case 'multiply' currentValue = currentValue * value; case 'divide' currentValue = currentValue / value; otherwise error('Unknown
operation'); end % Update history history(end+1) = currentValue; % Return both current value and history [Link] = currentValue; [Link] =
history; endend% Usage:% calc = calculateWithMemory(10);% result1 = calc('add', 5); % [Link] = 15% result2 = calc('multiply', 2); % [Link] = 30
Anonymous Functions

Quick Creation Compact Syntax

Create functions on-the-fly without Define simple functions in a single line
separate M-files of code

Closure Capability Function Handles

Capture and remember values from Store and pass functions as variables or
their creation context arguments
Anonymous Functions Syntax and Examples
Basic Syntax Using Anonymous Functions Capturing Variables

functionHandle = @(inputs) expression; % Call like regular functionsy = % Create function with fixed
square(5); % y = 25z = parametera = 5;f = @(x) a*x + 3;y
Examples: add(3, 4); % z = 7[m, s] = = f(2); % y = 13% Even
stats([1,2,3,4,5]);greeting(); if a changes later, f still uses%
% Displays: Hello, World!% the original valuea = 10;y = f(2);
% Square functionsquare = @(x)
Pass as function handlesy = % Still y = 13
x.^2;% Multiple inputsadd = @(a,b)
arrayfun(square, [1,2,3,4]);
a + b;% Multiple operationsstats =
% y = [1,4,9,16]%
@(x) [mean(x), std(x)];% No
Use in other
inputsgreeting = @() disp('Hello,
functionsfzero(square, 0); %
World!');
Find root of square
Function Handles
Creating Function Handles Storing Function Handles
• From existing functions: @functionName Function handles can be stored in variables, cell
• From anonymous functions: @(x) expression arrays, or structs for later use.

• From nested functions: returned directly

operations = { @(x,y) x+y, %
Addition @(x,y) x-y, %
Subtraction @(x,y) x*y, %
Multiplication @(x,y) x/y %
Division};

Passing as Arguments
Function handles can be passed to other functions, enabling powerful programming patterns.

% Integrate any function from a to bfunction result = integrate(func, a, b, n) % func

is a function handle x = linspace(a, b, n); y = func(x); result = trapz(x,
y);end% Usage:area = integrate(@sin, 0, pi, 1000);
Input to Script Files: Advanced Techniques

Command Line Input Dialog Boxes

Use input() function to request user data Create GUI input forms with inputdlg() for
during execution multiple inputs

Command-Line Arguments File Import

Pass values through the workspace before Load data from external files using load,
script execution csvread, or xlsread

While scripts don't have formal input parameters like functions, MATLAB provides several methods to supply data to scripts. The input()
function enables interactive data collection during runtime, prompting users with customized messages. For multiple inputs, inputdlg()
creates dialog boxes with labeled fields.

File-based input is particularly useful for batch processing, allowing scripts to work with large datasets from various sources. Pre-
defining variables in the workspace before running a script also serves as an effective input method, though this approach requires
careful documentation.
Input to a Script File
Pre-defined Variables
Variables created in workspace before running script

User Input Commands

Interactive input during script execution

File Input
Reading data from external files

Unlike functions, scripts don't have formal input parameters. However, there are several ways to provide input to scripts. Scripts
can use variables already defined in the workspace, collect user input during execution, or read data from external files.
Understanding these methods is essential for creating flexible and reusable scripts.
Using Pre-defined Workspace Variables
Approach Script Example

Create variables in the workspace before running the script. The

% cylinderCalc.m% Calculate cylinder volume and surface
script can then access these variables directly.
area% Expects radius and height in workspace% Check if
required variables existif ~exist('radius', 'var') ||
% In Command Window:radius = 5;height = 10;% Then run
~exist('height', 'var') error('radius and height
script:cylinderCalc
must be defined');end% Calculate volumevolume = pi *
radius^2 * height;% Calculate surface areasurfaceArea =
2*pi*radius*(radius + height);% Display
resultsdisp(['Volume: ',
num2str(volume)]);disp(['Surface Area: ',
num2str(surfaceArea)]);
Interactive User Input in Scripts
input Function inputdlg Function
Displays a prompt and waits for user to enter a value. Creates a dialog box with one or more input fields.
Can specify the expected data type. Returns a cell array of strings.

menu Function questdlg Function

Displays a menu of options and returns the index of the Creates a dialog box with Yes/No/Cancel buttons. Returns
selected option. the label of the selected button.
Input Function Examples
Basic Input Dialog Input

% Get numeric inputradius = input('Enter the % Create input dialog with multiple fieldsprompt
radius: ');% Get string input (note the 's' = {'Enter radius:', 'Enter height:'};dlgtitle =
parameter)name = input('Enter your name: ', 's'); 'Cylinder Parameters';dims = [1 35]; % Input
% Input with validationwhile true age = field sizedefinput = {'5', '10'}; % Default
input('Enter your age: '); if isnumeric(age) valuesanswer = inputdlg(prompt, dlgtitle, dims,
&& age > 0 break; end disp('Please definput);% Process results (returns cell array
enter a positive number');end of strings)if ~isempty(answer) radius =
str2double(answer{1}); height =
str2double(answer{2}); % Continue with
calculations...else disp('User cancelled
input');end
Menu and Selection Dialog Examples
Menu Function Question Dialog

% Create a menu of calculation optionsoption = menu('Select % Ask user a yes/no questionanswer = questdlg('Include detailed
calculation:', ... 'Area of Circle', ... 'Volume results?', ... 'Output Options', ...
of Sphere', ... 'Volume of Cylinder');% Process selection based 'Yes', 'No', 'Yes');% Process responseswitch answer case 'Yes'
on indexswitch option case 1 radius = input('Enter radius: '); detailed = true; case 'No' detailed = false; otherwise %
area = pi * radius^2; disp(['Area: ', num2str(area)]); case 2 User closed dialog or pressed Cancel disp('Operation cancelled');
radius = input('Enter radius: '); volume = (4/3) * pi * return;end% Use the selectionif detailed % Show detailed resultselse
radius^3; disp(['Volume: ', num2str(volume)]); case 3 % Show summary onlyend
radius = input('Enter radius: '); height = input('Enter height: ');
volume = pi * radius^2 * height; disp(['Volume: ',
num2str(volume)]); case 0 disp('No selection made');end
File Input in Scripts
Tabular Data Text Files MATLAB Data
Read structured Read Load variables
data from CSV, unstructured text from .mat files
Excel, or text files using fopen, using the load
using readtable, fread, textscan, function for
xlsread, or similar or fscanf efficient data
functions. functions. storage and
retrieval.

Image and
Media
Import images,
audio, or other
media using
specialized
functions like
imread or
audioread.
File Input Examples
Reading CSV Data Reading Text Files

% Read CSV file into a tabledata = readtable('[Link]');% % Open file for readingfileID = fopen('[Link]', 'r');% Check if
Access columns by nametime = [Link];temperature = file opened successfullyif fileID == -1 error('Could not open
[Link];% Calculate statisticsavgTemp = file');end% Read file line by lineconfig = struct();while
mean(temperature);maxTemp = max(temperature);% Display ~feof(fileID) line = fgetl(fileID); if ischar(line) &&
resultsdisp(['Average temperature: ', contains(line, '=') parts = split(line, '='); key =
num2str(avgTemp)]);disp(['Maximum temperature: ', strtrim(parts{1}); value = strtrim(parts{2}); config.
num2str(maxTemp)]); (key) = value; endend% Close the filefclose(fileID);
Output Commands: Communicating Results
Basic Display
disp(), fprintf() for text and numeric output

Visualization
plot(), surf(), imagesc() for graphical representation

File Output
3 save(), csvwrite(), xlswrite() for data persistence

Effective output commands are essential for communicating results from your MATLAB code. The disp() function provides simple text
output, while fprintf() offers formatted output with precise control over spacing, decimal places, and layout. These commands are vital
for creating readable reports and logging computational progress.

MATLAB's visualization capabilities transform abstract data into intuitive graphical representations. Functions like plot(), histogram(),
and imagesc() create visual insights that would be difficult to discern from raw numbers. For permanent storage of results, file output
commands enable data to be saved in various formats for future analysis or sharing with colleagues.
Output Commands in MATLAB
Visualization File Output
Create plots, charts, and Write data to external files in
graphical displays various formats
Command Window
Output GUI Elements
Display text and data in the Display information in dialog
Command Window boxes and custom interfaces
Command Window Output
disp Function fprintf Function
Displays the value of a variable or text without showing the variable name. Provides formatted output with precise control over appearance. Similar to
Adds a newline after output. C's printf function.

disp('Hello World');x = 42;disp(['The value is: ', x = 42; y = pi;fprintf('x = %d, y = %.4f\n', x, y);%
num2str(x)]); Outputs: x = 42, y = 3.1416

Direct Output Suppressing Output

Typing a variable name without semicolon displays its value with the variable name.
Adding a semicolon after a statement suppresses its output, useful for
scripts with many calculations.
x = 42% Outputs: x = 42
x = 42; % No output displayed
Formatted Output with fprintf
Basic Syntax Common Format Specifiers Format Modifiers

fprintf(format, A1, A2, ...) prints the • %d - Integer • %.2f - Control decimal places
arrays A1, A2, etc. according to the • %f - Floating-point number • %10s - Field width (right-aligned)
specified format.
• %e - Scientific notation • %-10s - Left-aligned field
• %g - Compact format (d or e) • %+d - Always show sign
fprintf('Hello, %s!\n',
• %s - String
'World');% Outputs: Hello,
• %c - Single character fprintf('%.2f | %-10s | %+d\
World!
n', ... 3.14159,
'MATLAB', 42);
Visualization Output

MATLAB provides powerful visualization capabilities to represent data graphically. Basic plotting functions like plot, bar, and scatter
create 2D visualizations, while surf, mesh, and contour generate 3D representations. These visualizations can be customized with
titles, labels, legends, and various styling options to create professional-quality figures for analysis and presentation.
Basic Plotting Examples
Line Plot Multiple Series Subplots

% Create x and y datax = % Create datax = 0:0.1:2*pi;y1 % Create datax = 0:0.1:2*pi;%

0:0.1:2*pi;y = sin(x);% Create = sin(x);y2 = cos(x);% Plot First subplotsubplot(2, 1,
basic plotplot(x, y);% Add multiple seriesplot(x, y1, 1);plot(x, sin(x));title('Sine
labels and 'b-', x, y2, 'r--');% Add Function');% Second
titlexlabel('Time');ylabel('Am legendlegend('sin(x)', subplotsubplot(2, 1,
plitude');title('Sine Wave');% 'cos(x)');% Add title and 2);plot(x, cos(x),
Add gridgrid on; labelstitle('Trigonometric 'r');title('Cosine Function');
Functions');xlabel('x');ylabel % Add common x-labelxlabel('x
('y'); (radians)');
File Output in MATLAB
Text Files
Write data to plain text files using fprintf with a file identifier, or
writetable for tabular data.

Spreadsheet Files
Export data to Excel or CSV formats using writematrix, writetable, or
xlswrite functions.

MATLAB Data Files

Save variables to .mat files using the save function for efficient
MATLAB-specific storage.

Image Files
Export figures and visualizations to various image formats using
saveas, print, or exportgraphics.
File Output Examples
Writing to Text Files Saving MATLAB Variables Exporting Figures

% Open file for writingfileID = % Create some variablesx = 1:10;y = % Create a figurex = 0:0.1:2*pi;y =
fopen('[Link]', 'w');% Write x.^2;results = table(x', y', sin(x);figure;plot(x, y);title('Sine
headerfprintf(fileID, 'Results of 'VariableNames', {'X', 'Y'});% Save Wave');xlabel('Time');ylabel('Amplitu
Analysis\n');fprintf(fileID, specific variablessave('[Link]', de');% Save as PNGsaveas(gcf,
'===================\n\n');% Write 'x', 'y');% Save all '[Link]');% Save as high-
datafor i = 1:5 x = i; y = x^2; variablessave('[Link]');% Save quality vector
fprintf(fileID, 'x = %d, y = %d\ with graphicexportgraphics(gcf,
n', x, y);end% Close compressionsave('[Link]', '[Link]', ...
filefclose(fileID); 'results', '-v7.3'); 'Resolution', 300);
GUI Output Elements
Message Dialogs Dialog Boxes Progress Custom GUIs
Indicators
Display information, Create custom dialog Build complete
warnings, or error boxes with various Show the progress of graphical interfaces
messages to the user. input and display long-running using App Designer or
elements. operations. GUIDE.
Dialog Box Examples
Message Dialog Progress Bar Custom Dialog

% Display information % Create waitbarh = waitbar(0, % Create figure for custom dialogfig
messagemsgbox('Calculation completed 'Processing...');% Update in a loopn = figure('Name', 'Results', ...
successfully', ... 'Operation = 100;for i = 1:n % Do some work 'Position', [300 300 400
Complete', 'help');% Display warning pause(0.05); % Update waitbar 200], ... 'MenuBar',
messagewarndlg('File already exists waitbar(i/n, h, 'none', ...
and will be overwritten', ... sprintf('Processing %d%%', ... 'NumberTitle', 'off');% Add
'Warning');% Display error round(i/n*100)));end% Close textuicontrol('Style', 'text', ...
messageerrordlg('Invalid input waitbarclose(h); 'String', 'Analysis
parameters', 'Error'); Results', ... 'Position',
[150 160 100 20]);% Add results
displayuicontrol('Style', 'text', ...
'String', sprintf('Mean:
%.2f\nStd: %.2f', ...
mean(data), std(data)), ...
'Position', [150 100 100 50]);
Combining Input and Output in
Scripts
Collect User Input
Use input functions or dialog boxes to gather parameters from the user.

Process Data
Perform calculations or data processing using the collected inputs.

Display Results
Show the results using appropriate output methods based on the
data type and complexity.

Save Output
Optionally save the results to files for future reference or further
analysis.
Complete Script Example
% dataAnalysis.m% A script to analyze numeric data with user interaction% Clear workspace and command windowclear;clc;% Ask user for input methodinputMethod = menu('Select input method:', ... 'Enter data manually', ... 'Load from file', ... 'Generate random data');% Get data based on selectionswitch
inputMethod case 1 % Manual input data = input('Enter data as vector (e.g., [1 2 3 4]): '); case 2 % File input [file, path] = uigetfile('*.csv;*.txt', 'Select data file'); if isequal(file, 0) disp('User cancelled operation'); return; end data = readmatrix(fullfile(path,
file)); case 3 % Random data n = input('Enter number of data points: '); data = randn(1, n); case 0 disp('User cancelled operation'); return;end% Calculate [Link] = mean(data);[Link] = median(data);[Link] = std(data);[Link] = min(data);[Link] = max(data);% Display results
in command windowdisp('Data Analysis Results:');disp('---------------------');disp(['Mean: ', num2str([Link])]);disp(['Median: ', num2str([Link])]);disp(['Standard Deviation: ', num2str([Link])]);disp(['Minimum: ', num2str([Link])]);disp(['Maximum: ', num2str([Link])]);% Create
visualizationfigure;subplot(2,1,1);histogram(data);title('Data Distribution');xlabel('Value');ylabel('Frequency');subplot(2,1,2);boxplot(data);title('Box Plot');% Ask if user wants to save resultssaveResults = questdlg('Save results to file?', ... 'Save Results', ... 'Yes', 'No', 'Yes'); if
strcmp(saveResults, 'Yes') % Save statistics to text file fileID = fopen('analysis_results.txt', 'w'); fprintf(fileID, 'Data Analysis Results\n'); fprintf(fileID, '====================\n\n'); fprintf(fileID, 'Mean: %.4f\n', [Link]); fprintf(fileID, 'Median: %.4f\n', [Link]); fprintf(fileID, 'Standard Deviation: %.4f\n',
[Link]); fprintf(fileID, 'Minimum: %.4f\n', [Link]); fprintf(fileID, 'Maximum: %.4f\n', [Link]); fclose(fileID); % Save figure saveas(gcf, 'analysis_plots.png'); % Confirm to user msgbox('Results saved successfully', 'Save Complete');end
Debugging MATLAB Code
Identify Errors
Use error messages and debugging tools to locate issues in your code.

Set Breakpoints
Pause execution at specific lines to examine the state of variables.

Step Through Code

Execute one line at a time to track the program flow.

Inspect Variables
Examine variable values and properties during execution.
Debugging Tools in MATLAB
Breakpoints
Set by clicking in the margin of the Editor or using the dbstop function. Execution
pauses when it reaches a breakpoint, allowing you to inspect the current state.

Step Commands
• Step: Execute the current line and pause
• Step In: Enter a function call
• Step Out: Complete the current function
• Continue: Resume until next breakpoint

Workspace Browser
Displays all variables in the current workspace during debugging, allowing you to
inspect their values and properties.

Command Window
Execute commands to examine or modify variables while paused at a breakpoint.
Useful for testing potential fixes.
Best Practices for MATLAB
Programming
Use Functions Over Scripts
Prefer functions for most code to improve modularity, reusability, and
prevent workspace conflicts.

Document Your Code

Add comprehensive comments and help text to make your code
understandable to others and your future self.

Validate Inputs
Always check input arguments for correct type, size, and value range to
prevent unexpected errors.

Modular Design
Break complex problems into smaller, focused functions that each do
one thing well.
More Best Practices
Optimize Performance
Preallocate arrays, vectorize operations, and avoid unnecessary
computations to improve execution speed.

Handle Errors Gracefully

Use try/catch blocks to prevent crashes and provide meaningful error
messages to users.

Use Version Control

Track changes to your code using Git or other version control systems
to maintain history and collaborate effectively.

Write Tests
Create test cases to verify your functions work correctly and continue
to work after changes.
Summary: MATLAB Programming Fundamentals
Mastery
Combine all elements for effective solutions

Input/Output
Manage data flow with various I/O methods

Functions
Create reusable, modular code components

Scripts
Automate sequences of commands

Throughout this presentation, we've explored the essential components of MATLAB programming, from basic scripts to advanced function
techniques. We've learned how to structure code effectively, manage inputs and outputs, and create reusable, modular solutions.

By applying these fundamentals and following best practices, you can develop efficient, maintainable MATLAB programs for a wide range of
scientific and engineering applications. Continue practicing these concepts to build your programming skills and tackle increasingly complex
problems.