That’s not how to use the ~ feature. Instead, the function would be something like this:

function myfunc(arg1, ~, arg3)

nargin

and nargin returns 3.  You can't, in the function body, refer to the second input.  It's there because some other use requires the second input, which this function will totally ignore.
The other use of ~ is to ignore defined outputs. See the example in the post or in the documentation.
--Loren

i.e. if my function is defined as

myfunc(argOne, argTwo, argThree)

and it’s called like this:

myfunc('arg', ~, 'arg')

Is nargin 2, or 3?
Is argTwo undefined or empty or something else?

Thanks

Choosing a symbol is partly a matter of taste, partly a matter to somehow conform to the rest of the language. We could have chosen _ as you suggest and preferred the looks and the fact that it meant “not” because we thought it would help people realize there was no value available.

–Loren

Sorry I misunderstood you. See Steve Lord’s answer regarding keywords. Introducing new ones also breaks compatibility.

–Loren

I’m talking about turning ‘unused’ into keyword that has the same behavior as ‘~’. That way for R2009b, there won’t be a variable called ‘unused’ to clutter the workspace, yet for older versions it won’t break the code for older versions, as they continue to exist as junk variables.

Even better, this scheme makes it possible to turn on/off this feature by enabling/disabling the keyword ‘unused’ without breaking any code in any version.

Cheers,
Hoi

I’m not sure you’re using ~ correctly in post 44. If by “If MATLAB calls my mexFunction with [x,y]=f(~,b)” you mean that you want to use ~ in the _input_ argument list when you _call_ the function, you can’t do that. Picture what would happen if you called, for example, PLUS like:

y = plus(x, ~);

What would you expect MATLAB to do in this case? You gave the PLUS function two inputs, as it expected, but you somehow expect it to ignore the second one?

You can use ~ in the _output_ argument list when you call the function (if you don’t care what value the function assigned to that output when you called it) and/or you can use it in the input argument list when you _define_ the function (if you’re going to ignore whatever the caller passed into the function.)

In a MEX-file, you can’t use ~ in the declaration, but you don’t need to. You can simply not reference that element of the array containing the right-hand sides, prhs. In MATLAB, doing that would earn you a warning from M-Lint:

function y = myfun(x, t) % t is not used
y = x.^2;

but M-Lint, as the name implies, doesn’t apply to MEX-file source code. Using ~ in the output argument list of a call to a function works the same way regardless of how the function is implemented — MEX, M-file, or built-in.

Hoi,

If we’d chosen to create a new keyword for this, it would have the potential to break older code that used the keyword as a variable or function name, as attempting to create a variable whose name is a keyword is an error:

for = 4;

and you can’t call a function whose name is a keyword — the keyword will take precedence.

It could be better to use ~ so you don’t clutter your workspace with stuff you don’t need.

Tim-

In your first example, you are looking to query inputs. Using ~ in your case is really not much different than using []. In any case, MATLAB doesn’t allow you to optionally use some input if the signature in MATLAB (not C) says it won’t use it. I think we are designing the C-Mex to mirror MATLAB usage. So either the function requires input #2 or it doesn’t.

I understand you also want to query whether some outputs are not wanted. Not currently possible in MATLAB or mex. It is on the wishlist for the future.

–Loren

Loren: any ideas why it’s better to use ‘~’?

Thanks for the feedback.

What I would like is something like this. If MATLAB calls my mexFunction with [x,y]=f(~,b) then inside the mexFunction f I should be able to query the first and 2nd argument to see if they are really there.

So why not pass me a null pointer for the 1st input argument to my mexFunction? that’s easy to do, and easy for me to check. Or pass an empty matrix, and then create a new query function that answers “do you exist?” for any input. The latter option would be safer, for backward compatibility.

And then for the output arguments, there could be another “do you exist?” query function that I could call.

It would make things like QR a lot easier, which has a boatload of “do this if you have 2 inputs and 1 output, something else if you have 1 input and 1 output, and …”, and likewise for many other mexFunctions.

These same functions, “do you exist?” applied to inputs and outputs, would be useful for m-file functions too. Something like this:

[x,y]=funky(a,b)
if (~isargpresent(a))
    fprintf ('Hey, you didn''t pass me anything for a!')
end
if (~isargpresent(x))
    fprintf ('Whatsa matter?! How come you don''t want x?') ;
end