arguments

Write a function that restricts the size of the input argument to a row vector of any length. Use a validation function to restrict the elements of that vector to numeric values.

function [m,s] = twoStats(x)
    arguments
        x (1,:) {mustBeNumeric}
    end
    m = mean(x,"all");
    s = std(x,1,"all");
end

Call the function on a three-element row vector.

a = [1 3 5];
[m,s] = twoStats(a)

m =

     3


s =

    1.6330

Calling the function with a column vector is also valid because row and column vectors are compatible.

a = [1 3 5]';
[m,s] = twoStats(a)

m =

     3


s =

    1.6330

If you call the function with a vector that contains nonnumeric values, the mustBeNumeric validation function throws an error.

a = ["1" "3" "5"];
[m,s] = twoStats(a)

Error using twoStats
Invalid argument at position 1. Value must be numeric.

To declare optional name-value arguments for a function, include a structure name in the function declaration, and define the argument names as fields of that structure in the arguments block.

Declare the myRectangle function with options as a structure name. The two fields of options, LineStyle and LineWidth, are the names in the function’s name-value arguments:

function myRectangle(X,Y,options)
    arguments
       X double
       Y double
       options.LineStyle (1,1) string = "-" 
       options.LineWidth (1,1) {mustBeNumeric} = 1
    end
    % Function code
    ...
end

Both of the argument names have defined default values, so they are both optional. All of these syntaxes are valid ways to call the function:

myRectangle(4,5)
myRectangle(4,5,LineStyle=":",LineWidth=2)
myRectangle(4,5,LineWidth=2,LineStyle=":")
myRectangle(4,5,LineStyle=":")
myRectangle(4,5,LineWidth=2)

Before R2021a, pass names as strings or character vectors, and separate names and values with commas. Both syntaxes are valid in later releases.

Repeating arguments are single arguments or groups of arguments that can be repeated zero or more times in a function call. The fRepeat function accepts repeating groups of arguments x, y, and style. Restrict the input arguments x and y to vectors of double values or values convertible to doubles. Restrict style to the strings "--" and ":".

function fRepeat(x,y,style)
    arguments (Repeating)
        x (1,:) double
        y (1,:) double
        style {mustBeMember(style,["--",":"])}       
    end
    
    % Reshape the cell arrays of inputs and call plot function
    z = reshape([x;y;style],1,[]);
    if ~isempty(z)
        plot(z{:});
    end
end

Call fRepeat with two groups of inputs. MATLAB creates a cell array containing all the values passed in for x, another array for the values of y, and a third for the values of style. The function then reshapes those arrays into a 1-by-6 cell array, z, and passes it to plot.

x1 = 1:10;
y1 = 1:10; 
s1 = ":"; 
x2 = 1:7;
y2 = 1:1.5:10;
s2 = "--";
fRepeat(x1,y1,s1,x2,y2,s2)

Write a function that rotates a two-dimensional square patch about point (0.4, 0.4) by a user-specified number of degrees. Return x- and y-coordinates of the final image as output arguments, and restrict those values to be positive. In other words, the function should return coordinates only when the final result of the rotation is entirely in the first quadrant.

function [xfinal,yfinal] = rotatePatch(angle)
    arguments (Output)
        xfinal {mustBePositive}
        yfinal {mustBePositive}
    end
    x = [0.1 0.1 0.7 0.7];
    y = [0.1 0.7 0.7 0.1];
    p = patch(x,y,"red");
    rotate(p,[0 0 1],angle,[0.4 0.4 0])
    xfinal = p.Vertices(:,1);
    yfinal = p.Vertices(:,2);
end

Call the function with an angle of 15 degrees. This rotation does not move any of the vertices out of the first quadrant, so the function returns without error.

[x1,y1] = rotatePatch(15)

x1 =

    0.1879
    0.0326
    0.6121
    0.7674


y1 =

    0.0326
    0.6121
    0.7674
    0.1879

Call the function with an angle of 35 degrees, which moves the lower-left vertex out of the first quadrant. The negative x-coordinate does not satisfy the output argument validation, so the function returns an error.

[x2,y2] = rotatePatch(35)

Invalid output 'xfinal'. Value must be positive.

Error in rotatePatch (line 12)
end

Write a function that accepts repeating pairs of vectors and returns the sum of each pair. Restrict the inputs and outputs to row vectors.

function vectorSum = repeatSum(a,b)
  arguments (Input,Repeating)
    a (1,:)
    b (1,:)
  end
  arguments (Output,Repeating)
    vectorSum (1,:)
  end

  n = numel(a);
  vectorSum{n} = a{n} + b{n};
  for i = 1:n-1
    vectorSum{i} = a{i} + b{i};
  end
end

Calculating the final output and assigning it to vectorSum{n} before the for-loop preallocates space for the cell array. Expanding the cell array in the loop without preallocation can have a negative effect on performance.

Define two pairs of vectors. Call repeatSum on with the two pairs as input. The input arguments block validation converts column vectors to row vectors because they are compatible sizes.

x1 = [1 2];
y1 = [3 4];
x2 = [1; 0];
y2 = [0; 1];
[sum1,sum2] = repeatSum(x1,y1,x2,y2)

sum1 =

     4     6


sum2 =

     1     1

Because the inputs are restricted to row vectors, the sum of each pair of vectors is always a row vector. However, the output validation helps ensure that the function produces row vectors even if the function is revised at a later date. For example, if the input validation were changed to the mustBeVector function, pairs could be composed of one row vector and one column vector without conversion. In that case, the sum of x1 and y2 is a matrix.

x1 + y2

ans =

     1     2
     2     3

The output of the revised repeatSum would error because the matrix would not pass the output validation.