This lecture explains the concept of functions in programming, in particular in MATLAB.

## Lecture Videos

This video is created solely as reference for the attendants of ICP2017F course at UT Austin. If you did not attend this class, then you may not find this video useful.

## Functions

Functions in programming languages are self-contained modules of code that accomplish a specific task. They usually (but not always) take some data as input, process the input data, and return a result. Therefore, the definition of function in programming goes far beyond the mathematical definition of function. For example, programming functions can have no input or output.

The main reason for writing functions is to reduce coding redundancy and increase code reuse. Once a function is written, it can be used over and over and over again. Whenever a function is needed, it can be called from the inside of the main program or from inside of other functions.

In MATLAB, like most other programming languages, function is a collection of programming statements that can be executed whenever and wherever requested. Both MATLAB scripts and functions allow you to reuse sequences of commands by storing them in program files. Scripts are the simplest type of program, since they store commands exactly as you would type them at the command line. Functions provide more flexibility, primarily because you can pass input values and return output values. The general syntax for a MATLAB function is the following,

function [y1,...,yN] = myfunc(x1,...,xM)
% here is the body of function


The above declares a function named myfunc that accepts inputs x1,...,xM and returns outputs y1,...,yN. This declaration statement must be the first executable line of the function. Just like MATLAB variables, valid function names begin with an alphabetic character, and can contain letters, numbers, or underscores.

You can save your function:

• In a function file which contains only function definitions. The name of the file should match the name of the first function in the file.
• In a script file which contains commands and function definitions. Functions must be at the end of the file. This may seem a bit odd to you, if you already know other programming languages, for example, Python. Script files cannot have the same name as a function in the file. Functions in scripts are supported only in MATLAB R2016b or later.

Files can include multiple local functions or nested functions. For readability, use the optional end keyword to indicate the end of each function in a file. The end keyword is required when:

• Any function in the file contains a nested function.
• The function is a local function within a function file, and any local function in the file uses the end keyword.
• The function is a local function within a script file.

In general, it is always good to add the end keyword to all functions, for better readability.

Example:
Let’s write a MATLAB function that takes in a temperature value in Centigrads and converts it to Fahrenheit.

function [F] = c2f(C)
F = (9.0/5)*C + 32;
end

c_temp = 70.7; % The hottest place on Earth, Lut Desert in Iran
f_temp = c2f(c_temp);
disp(['Temperature in Fahrenheit: ',num2str(f_temp)])
disp( ['The hottest place on Earth as of 2005 is in the Lut Desert in Iran at ' ...
, num2str(70.7) ...
, ' degrees Celsius.',char(10) ...
, 'This corresponds to a temperature of ', num2str(159.26), ' degrees Fahrenheits!' ...
] );

Temperature in Fahrenheit: 159.26
The hottest place on Earth as of 2005 is in the Lut Desert in Iran at 70.7 degrees Celsius.
This corresponds to a temperature of 159.26 degrees Fahrenheits!


### Functions with no input arguments

We can define functions that take no input argument, yet do something predefined for us. Consider the following function which gives information about the ICP course, when called.

function info = get_ICP_info()
info = 'ASE/COE 301: Introduction to Computer Programming (ICP) is a 3-hours credit course offered as part of the undergraduate coursework in the Aerospace and the Computational Engineering programs at The University of Texas at Austin.';
end

>> out = get_ICP_info()

ASE/COE 301: Introduction to Computer Programming (ICP) is a 3-hours credit course offered as part of the undergraduate coursework in the Aerospace and the Computational Engineering programs at The University of Texas at Austin.


### Functions with no output (return value)

We can also modify the above function such that it does not return anything specifically.

function get_ICP_info()
disp('ASE/COE 301: Introduction to Computer Programming (ICP) is a 3-hours credit course offered as part of the undergraduate coursework in the Aerospace and the Computational Engineering programs at The University of Texas at Austin.');
end

>> get_ICP_info()

ASE/COE 301: Introduction to Computer Programming (ICP) is a 3-hours credit course offered as part of the undergraduate coursework in the Aerospace and the Computational Engineering programs at The University of Texas at Austin.


This is almost equivalent to the word void in languages like Java, C, and C++. If you set a variable equal to this function, you will get an error message, because the function does not return anything as output.

>> out = get_ICP_info()
Error using get_ICP_info
Too many output arguments.


### Functions with multiple input arguments

Functions can take almost as many input arguments as we wish. Consider the following that takes two arguments,

function result = mypower(base,exponent)
result = base^exponent;
return
end

>> mypower(10,2)
ans =
100


#### Variable number of input arguments

The functions that we have written thus far have contained a fixed number of input arguments and a fixed number of output arguments. But you can also define a MATLAB function that accepts a variable number of inputs. In this case you use MATLAB’s builtin input argument cell varargin in place of the arbitrary number of input arguments. The function nargin returns the number of input arguments that were passed to the function. For example, consider the following function that displays the values of each input to the function,

function varlist(year,varargin)
fprintf('Number of arguments: %d\n',nargin)
celldisp(varargin)
fprintf('The year is %d\n',year)
fprintf('type of varargin is %s\n',class(varargin))
end

>> varlist(2017,'what','a ','nice', 'weather')
Number of arguments: 5
varargin{1} =
what
varargin{2} =
a
varargin{3} =
nice
varargin{4} =
weather
The year is 2017
type of varargin is cell


You can find more information about input/ouput function arguments here.

#### Optional arguments using inputParser

Unlike other languages such as Python, Fortran and C++, there is no simple direct way of having optional arguments in MATLAB functions, other than the one described above, using varargin. However, MATLAB has a powerful set of built-in capabilities known as inputParser for parsing the input arguments of a given function. The usage and details of this method goes beyond the scope of this class. However, you can learn more about it here.

### Functions with multiple output (return values)

MATLAB functions can also return more than one output value. The output could be of any type: vector, matrix, cell, structure, etc. For example, consider a function that takes an input vector of double and calculates its mean and standard deviation.

function [m,s] = stat(x)  % a function that returns the result as vector of length two
n = length(x);
m = sum(x)/n;
s = sqrt(sum((x-m).^2/n));
end

>> values = [12.7, 45.4, 98.9, 26.6, 53.1];
>> stat(values)
ans =
47.3400


Notice that if you don’t provide two output arguments, then basically only one is reported.

>> valuesMean = stat(values)
valuesMean =
47.3400

>> [valuesMean, valuesStd] = stat(values)
valuesMean =
47.3400
valuesStd =
29.4124

>> [valuesMean, valuesStd, dummy] = stat(values)   % too many output arguments is meaningless
Error using stat
Too many output arguments.

function [x,result] = stat(x) % the same function as above, but now returning the result as a structure, together with input x
result = struct();
result.n = length(x);
result.mean = sum(x) / result.n;
result.std = sqrt( sum( (x-result.mean).^2 / result.n ) );
end

>> values = [12.7, 45.4, 98.9, 26.6, 53.1];
>> stat(values)
ans =
12.7000   45.4000   98.9000   26.6000   53.1000

>> [input,ouput] = stat(values)
input =
12.7000   45.4000   98.9000   26.6000   53.1000
ouput =
n: 5
mean: 47.3400
std: 29.4124


Exercise
Write a function that takes in three coefficients $(a,b,c)$ of a quadratic equation $ax^2+bx+c$ and finds the roots of this equation.

function [x1,x2] = quadform(a,b,c)
d = sqrt(b^2 - 4*a*c);
x1 = (-b + d) / (2*a);
x2 = (-b - d) / (2*a);
end

>> [r1,r2] = quadform(1,1,1)
r1 =
-0.5000 + 0.8660i
r2 =
-0.5000 - 0.8660i


#### Variable number of output arguments

A variable number of output arguments can also be specified. For example, consider the following function typesize() which takes one input argument inputval. The function will always return a character specifying whether the input argument was a scalar (‘s’), vector (‘v’), or matrix (‘m’). This character is returned through the output argument arrtype. Additionally, if the input argument was a vector, the function also returns the length of the vector, and if the input argument was a matrix, the function returns the number of rows and the number of columns of the matrix. The MATLAB’s builtin output argument varargout is used, which is a cell array. So, for a vector the length is returned through varargout, and for a matrix both the number of rows and columns are returned through varargout,

function [arrtype, varargout] = typesize(inputval)
% typesize returns a character 'scalar' for scalar, 'vector'
% for vector, or 'matrix' for matrix input argument
% also returns length of a vector or dimensions of matrix
% Format: typesize(inputArgument)
[nrow, ncol ] = size(inputval);
if nrow==1 && ncol==1
arrtype = 'scalar';
elseif nrow==1 || ncol==1
arrtype = 'vector';
varargout{1} = length(inputval);
else
arrtype = 'matrix';
varargout{1} = nrow;
varargout{2} = ncol;
end
end

>> typesize(10)
ans =
scalar
>> typesize(10:12)
ans =
vector
>> [inputType,inputLength] = typesize(10:12)
inputType =
vector
inputLength =
3
>> [inputType,nrow,ncol] = typesize([10:12;13:15])
inputType =
matrix
nrow =
2
ncol =
3