[MUSIC] Back in lesson four,
we introduced polymorphic functions. Remember that polymorphic functions are
functions that behave differently based on the number of input arguments or output
arguments that they're called with or even the type of input or
output arguments. Many built-in functions of polymorphic,
such as the square root function, max, size, plot and on and on. It's one of MATLAB's strongest features. How we make I functions polymorphic? What's actually quite simple, really? The reason we waited until now to
show you is we really couldn't do it right without if statements. Now we'll combine if statements with
a couple of built-in functions that we haven't mentioned yet. First one's nargin or nargin,
which means number of arguments input. It gives the number of actual input
arguments that the caller passed in. The other ones nargout or in nargout. It returns the number of actual output
arguments that the caller requested. These two functions can be called
from inside our functions to make our functions polymorphic. Here's a function declaration of
a function called called multable with two output arguments and
two input arguments. It returns in n-by-m multiplication table
in the output argument called table. Optionally, it can also return the sum
of all elements in the output argument in the variable summa. If it's called with only one input
argument, it returns and n-by-m matrix. So let's see the code. First, we check to see whether
the function was called with one or two arguments. If nargin is smaller than two, then it
was called with only a single argument. A single argument is always
put in the first position, which in this case is the variable n. When m is omitted,
we're supposed to return an n-by-m matrix, so we set m equal to n. This is a classic example of setting a
default value for an input that's omitted. Now we're ready to compute
the multiplication table. It's actually pretty simple. We create two row vectors, one going from
one to n and the other from one to m. We transpose the first vector
to be a column vector and use matrix multiplication
to create the table. Now, it's time to determine whether
we need to compute the sum of the matrix as well. We need to do that only if the user
requested a second output argument. So we check nargout. If it's two, we call the sum function. Remember that sum computes the sums
of the columns of a matrix and returns them in a vector? Well, that's not what we want. So here, we use the column argument to create a
vector from all the elements of the table. That's done with a colon. And then we sum and give that to sum and
it'll add them all up. If nargout is one,
then we avoid sum entirely. But there's no harm in computing summa,
even if the caller doesn't request it. If we calculate it when
the user doesn't request it, MATLAB will simply discard it
when the function returns. So, all we've done is save a few
microseconds of calculation time here. But you will definitely want to use
nargout to avoid long calculations, perhaps many minutes when
the user doesn't ask for them. In any case,
here's our first polymorphic function. Let's see it in action. Well, here's our mult table function
in the Editor all ready to go. Let's pitch it a few different
inputs to see how well it does. [SOUND] There we gave it three by four and
it gives us a three by four array and that looks like a multiplication table. Let's ask it for a couple of outputs. There's a table and there's the sum and
that's the correct sum. Okay.
This time, we're just asked for one output and, but
we only gave it one input argument and you'll remember that, that defaults
to five by five instead of just five. So far so good. It's hitting them out of the park. Lets see how it handles a curve ball. Well, we managed to make it fail
by giving it no argument at all. MATLAB tells us the line on
which the failure occurred and we can see what happened
on that line right here. When MATLAB tried to
look up the value of n, it found no value of n,
because we gave it no value. Well, it might seem like cheating,
more like a spit ball than a curve ball. Let's be a little more fair. Let's give it some arguments. Well let's do this. Hm, I've got the empty matrix back. Clearly, we didn't plan
on negative inputs, but can you see where
the empty matrix came from? Well, the colon operator here,
one to n on line seven became one to minus 3,
because we gave a minus 3 for n. And the one colon m
became one colon minus 5. And as we saw way back in lesson two when
the end is less than the beginning and we don't get, include a negative increment
with it, the result's an empty matrix. Here we've got two of them. And now we see that the product of two
empty matrices is also an empty matrix. So now we can understand why
we got the empty matrix here. [SOUND] And we can also
understand why we got this error. But both of these cases
represent traps for the user, we should do something about them. [MUSIC] [APPLAUSE]
