Input and output arguments in MATLAB - Deep Dive

Overview - Input and output arguments

What is it?

Input and output arguments are the way functions in MATLAB receive data and return results. Inputs are values or variables you give to a function to work with. Outputs are the results the function sends back after processing. This lets you reuse code by giving different inputs and getting different outputs.

Why it matters

Without input and output arguments, functions would be fixed and useless for different data. They allow you to write flexible, reusable code that can handle many situations. This saves time and reduces errors because you don’t rewrite the same code for every case. It also helps organize your work clearly.

Where it fits

Before learning input and output arguments, you should understand basic MATLAB syntax and how to write simple functions. After this, you can learn about advanced function features like variable numbers of inputs/outputs, nested functions, and anonymous functions.

Mental Model

Core Idea

Input arguments are the data you give to a function, and output arguments are the data the function sends back after processing.

Think of it like...

Think of a function like a vending machine: you put money and a selection code in (inputs), and the machine gives you a snack or drink out (outputs).

┌───────────────┐
│   Function    │
│               │
│ Inputs  →     │
│               │
│     ← Outputs │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

What are function inputs and outputs

Concept: Functions take inputs to work on and produce outputs as results.

In MATLAB, a function can have inputs listed in parentheses after its name. Outputs are listed in square brackets before the function name. For example: function [sum] = addNumbers(a, b) sum = a + b; end Here, 'a' and 'b' are inputs, and 'sum' is the output.

Result

You can call addNumbers(3, 5) and get 8 as the output.

Understanding inputs and outputs is the foundation for making functions useful and reusable.

2

Foundation

Calling functions with arguments

Concept: You provide actual values (arguments) when calling a function to replace its inputs.

When you use a function, you give it specific values for its inputs. For example: result = addNumbers(10, 20); This sends 10 and 20 into the function as 'a' and 'b'. The function returns 30, which is stored in 'result'.

Result

The variable 'result' now holds the value 30.

Knowing how to call functions with inputs lets you use the same function for many different values.

3

Intermediate

Multiple outputs from one function

🤔Before reading on: do you think a function can return more than one output at once? Commit to yes or no.

Concept: Functions can return several outputs by listing them in square brackets.

You can write functions that give back multiple results. For example: function [sum, diff] = addAndSubtract(a, b) sum = a + b; diff = a - b; end Call it like this: [s, d] = addAndSubtract(7, 3); Now 's' is 10 and 'd' is 4.

Result

You get two outputs from one function call, stored in separate variables.

Multiple outputs let one function do several related calculations at once, making code cleaner.

4

Intermediate

Optional inputs and default values

🤔Before reading on: do you think MATLAB functions automatically handle missing inputs? Commit to yes or no.

Concept: Functions can check if inputs are missing and assign default values inside the code.

MATLAB does not automatically fill missing inputs. You must write code to handle this: function result = powerNumber(x, p) if nargin < 2 p = 2; % default power is 2 end result = x ^ p; end Calling powerNumber(3) returns 9 because p defaults to 2.

Result

The function works even if you omit some inputs, using defaults.

Handling optional inputs makes functions more flexible and user-friendly.

5

Intermediate

Variable number of inputs and outputs

🤔Before reading on: can a function accept any number of inputs or outputs? Commit to yes or no.

Concept: MATLAB supports functions that can take or return varying numbers of arguments using special variables.

Use varargin and varargout to handle flexible inputs and outputs: function varargout = exampleFunc(varargin) nIn = length(varargin); for k = 1:nIn varargout{k} = varargin{k} * 2; end end Calling [a,b] = exampleFunc(2,3) returns a=4, b=6.

Result

Functions can adapt to different numbers of inputs and outputs dynamically.

This feature allows writing very general functions that work in many situations.

6

Advanced

Passing inputs by value vs reference

🤔Before reading on: do MATLAB function inputs change the original variables outside the function? Commit to yes or no.

Concept: MATLAB passes inputs by value, so changes inside functions do not affect original variables unless outputs are assigned back.

When you pass a variable to a function, MATLAB makes a copy. Modifying it inside the function does not change the original: function changeVal(x) x = 10; end v = 5; changeVal(v); % v is still 5 To update 'v', assign the output: function y = changeVal(x) y = 10; end v = changeVal(v); % v is now 10

Result

Original variables remain unchanged unless outputs are used to update them.

Knowing this prevents bugs where you expect inputs to change but they don’t.

7

Expert

Hidden outputs and side effects in functions

🤔Before reading on: can MATLAB functions produce results without explicit output arguments? Commit to yes or no.

Concept: Functions can modify data or display results without returning outputs, causing side effects.

A function can change global variables, write to files, or plot graphs without outputs: function plotSquare(x) y = x.^2; plot(x,y); end Calling plotSquare(1:5) shows a graph but returns no output. This can confuse users expecting outputs or pure functions.

Result

Functions may have effects beyond outputs, which can be useful or risky.

Understanding side effects helps write clearer, more predictable code and avoid hidden bugs.

Under the Hood

When a MATLAB function is called, the interpreter creates a new workspace for it. Inputs are copied into this workspace as local variables. The function runs its code using these copies. Outputs are assigned to variables in the caller's workspace only when the function finishes and returns. This separation ensures functions do not accidentally change outside variables unless explicitly designed to do so.

Why designed this way?

MATLAB uses pass-by-value to avoid unexpected changes to data, making debugging easier. This design favors safety and clarity over performance in most cases. Alternatives like pass-by-reference can cause hidden bugs if functions change inputs without the caller knowing. MATLAB allows some exceptions with handle classes, but the default is pass-by-value for simplicity.

Caller Workspace
┌───────────────┐
│ var1, var2    │
└──────┬────────┘
       │ call function
       ▼
Function Workspace
┌─────────────────────┐
│ Inputs: var1_copy   │
│         var2_copy   │
│ Processing code     │
│ Outputs: out1, out2 │
└─────────┬───────────┘
          │ return outputs
          ▼
Caller Workspace
┌───────────────┐
│ out1, out2    │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: do you think MATLAB functions can change input variables without returning outputs? Commit yes or no.

Common Belief: Functions can modify input variables directly without returning them.

Reality: MATLAB passes inputs by value, so original variables stay unchanged unless outputs are assigned back.

Why it matters: Expecting inputs to change without outputs leads to bugs where variables do not update as intended.

Quick: do you think a function must always have output arguments? Commit yes or no.

Common Belief: Every function must return outputs to be useful.

Reality: Functions can perform actions like plotting or saving files without outputs, called side effects.

Why it matters: Not knowing this can cause confusion when functions seem to do nothing because they return no outputs.

Quick: do you think MATLAB automatically fills missing input arguments? Commit yes or no.

Common Belief: If you call a function with fewer inputs, MATLAB fills missing ones automatically.

Reality: MATLAB does not fill missing inputs; the function must check and assign defaults explicitly.

Why it matters: Assuming automatic filling causes errors or unexpected behavior when inputs are missing.

Quick: do you think multiple outputs must always be captured when calling a function? Commit yes or no.

Common Belief: If a function returns multiple outputs, you must always capture them all.

Reality: You can capture only some outputs; MATLAB assigns outputs in order to variables you provide.

Why it matters: Knowing this allows flexible use of functions without unnecessary variables.

Expert Zone

1

Functions with many outputs can be designed to return only what the user requests, improving efficiency.

2

Using varargin and varargout allows creating highly flexible functions but can make debugging harder if not documented well.

3

Handle classes in MATLAB allow pass-by-reference behavior, which changes the usual input/output argument model.

When NOT to use

Avoid complex variable input/output functions when clarity is more important than flexibility. Instead, use fixed inputs and outputs for easier maintenance. For performance-critical code, consider handle classes or object-oriented approaches to avoid copying large data.

Production Patterns

In real projects, functions often use input parsing functions like inputParser to handle optional arguments cleanly. Multiple outputs are used to return both results and status flags. Side effects like logging or plotting are separated from pure computation functions to keep code modular.

Connections

Function signatures in programming

Input and output arguments define a function’s signature, similar across many languages.

Understanding MATLAB’s input/output model helps grasp how functions work in other languages like Python or C++.

Encapsulation in Object-Oriented Programming

Input/output arguments control data flow into and out of functions, similar to how encapsulation controls access to object data.

Knowing this connection clarifies how functions and objects manage data boundaries.

Black box testing in software engineering

Functions with inputs and outputs can be tested as black boxes by checking outputs for given inputs.

This helps understand testing strategies that focus on input-output behavior without internal details.

Common Pitfalls

#1 Expecting input variables to change inside the function without returning outputs.

Wrong approach:

function changeVal(x)
x = 10;
end

v = 5;
changeVal(v);
% Expect v to be 10 but it remains 5

Correct approach:

function y = changeVal(x)
y = 10;
end

v = 5;
v = changeVal(v);
% v is now 10

Root cause:

Misunderstanding MATLAB’s pass-by-value input argument behavior.

#2 Calling a function with missing inputs without handling defaults.

Wrong approach:

function result = powerNumber(x, p)
result = x ^ p;
end

powerNumber(3);
% Error: Not enough input arguments

Correct approach:

function result = powerNumber(x, p)
if nargin < 2
p = 2;
end
result = x ^ p;
end

powerNumber(3);
% Returns 9

Root cause:

Assuming MATLAB fills missing inputs automatically.

#3 Ignoring outputs when function returns multiple values needed for correct results.

Wrong approach:

[sum] = addAndSubtract(5, 3);
% Only sum captured, diff is lost

Correct approach:

[sum, diff] = addAndSubtract(5, 3);
% Both outputs captured

Root cause:

Not understanding how MATLAB assigns multiple outputs.

Key Takeaways

Input arguments provide data to functions, and output arguments return results, enabling reusable code.

MATLAB passes inputs by value, so changes inside functions do not affect original variables unless outputs are assigned back.

Functions can have multiple outputs and handle variable numbers of inputs and outputs for flexibility.

Handling optional inputs requires explicit code to assign default values; MATLAB does not do this automatically.

Functions may produce side effects without outputs, so understanding input/output arguments is key to writing clear, predictable code.