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, ...
end

If there is only one output, you can omit the square brackets:

function out = myFunction(in1, in2)
    % Compute something
end

If there are no outputs, you omit the output part entirely:

function myFunction(in1, in2)
    % Perform an action but do not return a value
end

The 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;
end

You 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;
end

You 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;
end

You can assign that single output to a variable:

result = squareNumber(4);   % result is 16

Functions 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;
end

You capture them like this:

[s, p] = sumAndProduct(3, 4);   % s = 7, p = 12

The 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);
end

You can ignore the second output like this:

m = myMinMax([4 2 7]);     % Only first output is captured

Or 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;
end

You 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);
end

You 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 outputs

If 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
end

Calling:

[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;
end

You 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);
end

is much clearer than:

function r = f(a, b)
    r = a ./ (b.^2);
end

Clear 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.