6.2. Function Inputs and Outputs
Table of Contents
Why Function Inputs and Outputs Matter
In MATLAB, functions are most useful when they can work with different data. Inputs let you pass information into a function so that it can perform its task on that specific data. Outputs let the function give information back to the caller. Understanding how to define, use, and control inputs and outputs is essential if you want to write flexible and reusable code.
This chapter focuses on how to declare inputs and outputs in MATLAB function definitions, how they behave, and some useful patterns for beginners.
Basic Syntax for Inputs and Outputs
A MATLAB function is declared at the top of a file with a function line. Inputs are written in parentheses after the function name. Outputs are written in square brackets before the equals sign.
Here is the general pattern:
function [out1, out2, ...] = functionName(in1, in2, ...)
% Function body that uses in1, in2, ...
% and assigns values to out1, out2, ...
endIf there is only one output, you can omit the square brackets:
function out = myFunction(in1, in2)
% Compute something
endIf there are no outputs, you omit the output part entirely:
function myFunction(in1, in2)
% Perform an action but do not return a value
endThe order in which you list inputs and outputs matters. MATLAB matches values by position, not by name.
Calling a Function with Inputs
When you call a function, you pass arguments in the same order that the inputs are declared. For example, suppose you have:
function area = rectangleArea(width, height)
area = width * height;
endYou can call it like this:
a = rectangleArea(3, 5);
Here, 3 is passed into width and 5 into height. MATLAB does not know or care about the variable names in the caller. It uses only the positions. For example:
w = 10;
h = 2;
A = rectangleArea(h, w); % width = h = 2, height = w = 10
This will give A = 20, not A = 100, because h is passed in first.
Inputs in the function are local variables inside that function. Changing them inside the function does not change the variables in the caller.
Multiple Inputs and Optional Behavior
You can declare any number of inputs. MATLAB does not require you to specify types in the function definition. The same function can accept scalars, vectors, matrices, or even other types, as long as the code inside handles them correctly.
For example:
function total = addThree(a, b, c)
total = a + b + c;
endYou call it with three arguments:
s = addThree(1, 2, 3);If you try to call it with a different number of arguments, such as:
s = addThree(1, 2);MATLAB will raise an error. Handling a variable number of inputs is possible, but it uses special techniques and functions that are beyond this chapter. Here we stay with fixed numbers of inputs.
Single Output vs Multiple Outputs
Many MATLAB functions return a single output:
function y = squareNumber(x)
y = x.^2;
endYou can assign that single output to a variable:
result = squareNumber(4); % result is 16Functions can also return multiple outputs. These are declared in square brackets and separated by commas:
function [sumVal, productVal] = sumAndProduct(a, b)
sumVal = a + b;
productVal = a * b;
endYou capture them like this:
[s, p] = sumAndProduct(3, 4); % s = 7, p = 12The order is important. The first output in the definition corresponds to the first variable on the left side of the call, the second output to the second variable, and so on.
Ignoring Outputs with Tilde
Sometimes a function returns several outputs but you only care about some of them. MATLAB lets you ignore outputs by using a tilde ~ in the place of an output variable.
For example, MATLAB’s built in function min can return both a minimum value and its index. If your own function returns multiple outputs, you can call it in the same style:
function [minimum, maximum] = myMinMax(x)
minimum = min(x);
maximum = max(x);
endYou can ignore the second output like this:
m = myMinMax([4 2 7]); % Only first output is capturedOr ignore the first and keep the second:
[~, maxVal] = myMinMax([4 2 7]);
Inside myMinMax, both minimum and maximum are still computed. You are only choosing not to store some of them at the call site.
Functions Called with Fewer Outputs
A useful feature in MATLAB is that a function can be written to provide several outputs, but the caller does not have to request all of them.
For example, consider again:
function [sumVal, productVal] = sumAndProduct(a, b)
sumVal = a + b;
productVal = a * b;
endYou can call it in three different ways:
% Request both outputs
[s, p] = sumAndProduct(2, 5);
% Request only the sum
s = sumAndProduct(2, 5);
% Request nothing (still executes, values discarded)
sumAndProduct(2, 5);When you request fewer outputs than the function can provide, MATLAB simply discards the extra ones. The function body still runs in the same way. This is very common in MATLAB built in functions and is a pattern you can follow in your own code.
You cannot request more outputs than the function defines. If you try:
[a, b, c] = sumAndProduct(2, 5);MATLAB will report an error, because the function only defines two outputs.
Returning No Outputs
A function can also be written to act only by producing side effects, such as printing text or creating a figure, and not by returning data.
For example:
function greet(name)
fprintf('Hello, %s!\n', name);
endYou call it as:
greet('Alice');Trying to assign its result to a variable will give an error:
x = greet('Alice'); % This is not allowed, function has no outputsIf you later decide that you want the function to return something, you must change the function definition to include an output variable and assign a value to that variable inside the function.
Output Variables as Function Results
In a MATLAB function, outputs are determined entirely by the values of the output variables at the moment the function ends. The general rule is:
The outputs of the function are the final values of the variables named in the output list.
If an output variable is never assigned inside the function, MATLAB returns it as an empty array []. For example:
function [out1, out2] = example(x)
out1 = x^2;
% out2 is never assigned
endCalling:
[a, b] = example(3);
gives a = 9 and b = [].
For clarity, beginners should usually assign all declared outputs inside the function, and preferably in a consistent way for all possible inputs.
Default and Optional Input Behavior
Although MATLAB does not have built in syntax for default argument values in the function declaration, you can simulate default behavior inside the function body. The idea is that you check how many inputs were actually provided, and then fill in missing ones with default values.
This chapter does not go into the full details of using nargin, but a simple pattern can be illustrated. Consider:
function y = scaleValue(x, factor)
if nargin < 2
factor = 1; % default factor if none provided
end
y = x * factor;
endYou can now call the function with one or two inputs:
a = scaleValue(10); % factor defaults to 1, a = 10
b = scaleValue(10, 3); % factor = 3, b = 30
Inside the function, if the caller did not pass a second input, factor is assigned a default value.
Similarly, you can allow extra behavior when more inputs are given, but the detailed techniques and special variables that support this will be covered in later topics.
Naming and Meaningful Interfaces
The names you choose for inputs and outputs form the visible interface of your function. Meaningful names make your function easier to understand and use. For example:
function bmi = bodyMassIndex(weightKg, heightM)
bmi = weightKg ./ (heightM.^2);
endis much clearer than:
function r = f(a, b)
r = a ./ (b.^2);
endClear names, combined with a short comment explaining what the inputs and outputs represent, make your functions self documenting and easier to reuse. The actual variable names that the caller uses do not need to match, but the function definition should clearly express its intended use.
Summary of Key Ideas
Views: 0
Where to Move
Move chapter:
- ☰ 1. Getting Started with MATLAB
- ☰ 1.1. What Is MATLAB and What Is It Used For
- ☰ 1.2. Installing MATLAB and Setting Up the Environment
- ☰ 1.3. Understanding the MATLAB Desktop Interface
- ☰ 1.4. Command Window, Workspace, and Current Folder
- ☰ 1.5. Basic Workflow and Running Simple Commands
- ☰ 1.6. Getting Help and Documentation
-
- ☰ 2. MATLAB Language Basics
- ☰ 2.1. MATLAB Syntax and Expressions
- ☰ 2.2. Variables and Assignment
- ☰ 2.3. Data Types and Type Conversion
- ☰ 2.4. Vectors and Matrices Fundamentals
- ☰ 2.5. Creating and Indexing Arrays
- ☰ 2.6. Basic Arithmetic and Elementwise Operations
- ☰ 2.7. Using Built-In Constants and Functions
-
- ☰ 3. Working with Variables and the Workspace
- ☰ 3.1. Creating, Viewing, and Editing Variables
- ☰ 3.2. Workspace Browser and Variable Inspector
- ☰ 3.3. Saving and Loading Data Files
- ☰ 3.4. MAT-Files and Importing External Data
- ☰ 3.5. Clearing Variables and Managing the Workspace
-
- ☰ 4. Vectors, Matrices, and Arrays
- ☰ 4.1. Row and Column Vectors
- ☰ 4.2. Matrix Creation and Concatenation
- ☰ 4.3. Indexing, Slicing, and Logical Indexing
- ☰ 4.4. Matrix Operations vs Elementwise Operations
- ☰ 4.5. Reshaping and Rearranging Arrays
- ☰ 4.6. Special Matrices and Functions
-
- ☰ 5. Basic Programming Constructs
- ☰ 5.1. Scripts vs Functions
- ☰ 5.2. Control Flow with if, elseif, else
- ☰ 5.3. Loops with for and while
- ☰ 5.4. break, continue, and return
- ☰ 5.5. Logical Expressions and Relational Operators
- ☰ 5.6. Best Practices for Clear and Readable Code
-
- ☰ 6. Functions in MATLAB
- ☰ 6.1. Creating Simple Functions
- ☰ 6.2. Function Inputs and Outputs
- ☰ 6.3. Function Files and the Path
- ☰ 6.4. Local vs Global Variables
- ☰ 6.5. Anonymous Functions
- ☰ 6.6. Organizing Code into Multiple Functions
-
- ☰ 7. Working with Numbers and Math
- ☰ 7.1. Scalars and Vectorized Computations
- ☰ 7.2. Basic Mathematical Functions
- ☰ 7.3. Trigonometric and Exponential Functions
- ☰ 7.4. Complex Numbers in MATLAB
- ☰ 7.5. Rounding, Modulo, and Special Values
- ☰ 7.6. Numerical Precision and Floating Point Considerations
-
- ☰ 8. Strings, Characters, and Categorical Data
- ☰ 8.1. Character Arrays and String Arrays
- ☰ 8.2. Creating and Manipulating Strings
- ☰ 8.3. Converting Between Data Types and Strings
- ☰ 8.4. Comparing and Searching Strings
- ☰ 8.5. Categorical Arrays Basics
-
- ☰ 9. Tables, Structures, and Cell Arrays
- ☰ 9.1. Introduction to Tables
- ☰ 9.2. Creating Tables and Accessing Data
- ☰ 9.3. Modifying and Joining Tables
- ☰ 9.4. Structures and Nested Structures
- ☰ 9.5. Cell Arrays and Cell Indexing
- ☰ 9.6. Choosing the Right Container Type
-
- ☰ 10. Importing and Exporting Data
- ☰ 10.1. Reading Text and CSV Files
- ☰ 10.2. Importing Excel Spreadsheets
- ☰ 10.3. Importing Data with the Import Tool
- ☰ 10.4. Exporting Data to Files
- ☰ 10.5. Working with Image and Audio Files
- ☰ 10.6. Basic File Management from MATLAB
-
- ☰ 11. Plotting and Visualization
- ☰ 11.1. Introduction to 2D Plotting
- ☰ 11.2. Customizing Plots and Axes
- ☰ 11.3. Multiple Plots in One Figure
- ☰ 11.4. Labels, Titles, Legends, and Annotations
- ☰ 11.5. Plotting with Different Line and Marker Styles
- ☰ 11.6. Saving and Exporting Figures
-
- ☰ 12. Advanced Plotting for Beginners
- ☰ 12.1. Subplots and Tiled Layouts
- ☰ 12.2. Bar, Scatter, and Stem Plots
- ☰ 12.3. Histograms and Density Plots
- ☰ 12.4. 3D Plots and Surface Plots
- ☰ 12.5. Using plottools and Interactive Editing
- ☰ 12.6. Basics of Handle Graphics
-
- ☰ 13. Working with Scripts and Live Scripts
- ☰ 13.1. Creating and Running Script Files
- ☰ 13.2. Sectioning Code and Running Sections
- ☰ 13.3. Live Scripts and Rich Text
- ☰ 13.4. Adding Equations, Images, and Outputs
- ☰ 13.5. Sharing and Exporting Live Scripts
-
- ☰ 14. Debugging and Code Quality
- ☰ 14.1. Finding and Fixing Syntax Errors
- ☰ 14.2. Setting Breakpoints and Stepping Through Code
- ☰ 14.3. Inspecting Variable Values During Execution
- ☰ 14.4. Using the Editor Debugging Tools
- ☰ 14.5. Using Code Analyzer and Warnings
- ☰ 14.6. Writing Clean and Maintainable MATLAB Code
-
- ☰ 15. Basic Linear Algebra with MATLAB
- ☰ 15.1. Vectors and Norms
- ☰ 15.2. Matrix Addition and Multiplication
- ☰ 15.3. Solving Linear Systems with Backslash
- ☰ 15.4. Inverses, Determinants, and Rank
- ☰ 15.5. Eigenvalues and Eigenvectors
- ☰ 15.6. Using Linear Algebra Functions Safely
-
- ☰ 16. Data Analysis and Statistics Fundamentals
- ☰ 16.1. Descriptive Statistics and Summary Measures
- ☰ 16.2. Sorting, Filtering, and Grouping Data
- ☰ 16.3. Basic Correlation and Regression
- ☰ 16.4. Simple Data Cleaning Techniques
- ☰ 16.5. Basic Time Series Handling
-
- ☰ 17. Working with Time and Dates
- ☰ 17.1. Representing Dates and Times
- ☰ 17.2. Creating and Formatting datetime Arrays
- ☰ 17.3. Date Calculations and Differences
- ☰ 17.4. Plotting Data over Time
-
- ☰ 18. Introduction to Signal and Image Handling
- ☰ 18.1. Basic Signal Representation in MATLAB
- ☰ 18.2. Simple Filtering and Transformations
- ☰ 18.3. Reading, Displaying, and Writing Images
- ☰ 18.4. Basic Image Transformations
-
- ☰ 19. Automation and Scripting Tasks
- ☰ 19.1. Batch Processing of Files
- ☰ 19.2. Writing Reusable Utility Scripts
- ☰ 19.3. Using Relative Paths and the MATLAB Path
- ☰ 19.4. Simple User Interaction with input and disp
-
- ☰ 20. Introduction to Toolboxes
- ☰ 20.1. What Are Toolboxes and How to Use Them
- ☰ 20.2. Exploring Installed Toolboxes
- ☰ 20.3. Finding Functions in Toolboxes
- ☰ 20.4. Add-Ons and MATLAB File Exchange
-
- ☰ 21. Best Practices and Next Steps
- ☰ 21.1. Organizing Projects and Folders
- ☰ 21.2. Version Control Basics with MATLAB
- ☰ 21.3. Performance Tips for Beginners
- ☰ 21.4. Learning Resources and Documentation Path
- ☰ 21.5. Suggested Practice Projects for Beginners
-
Comments
Please login to add a comment.
Don't have an account? Register now!