How to get the variable numbers for a julia function

General Usage
#1

I have a function called f for example.

function f(x1,x2,x3)
x1+x2*x3
end

How can get the number of variable of this function? For this example it should return 3.

2 Likes
#2

You can do something like this:

julia> function f(args...)
           return length(args)
       end
f (generic function with 1 method)

julia> f(1,2,3)
3
3 Likes
#3

What are you trying to accomplish? The analogue of nargin in Matlab in Julia is to define multiple methods (or optional/keyword arguments).

5 Likes
#4

No. How to use the ā€œaccomplishā€? I tried

accomplish(f)

But it seems not works. By the way, the ā€œnarginā€ in Matlab does works.

#5

Heā€™s asking what you are trying to do. There is no accomplish function.

In Matlab nargin is an important function that you need to use all the time to figure out what inputs you have. In Julia you donā€™t need this at all.

Edit: I meant to reply to @gangchern

6 Likes
#6

Matlab:

function ret = f(x1,x2)
    if nargin == 1
        ret = x1;
    elseif nargin == 2
        ret = x1+x2;
    end
end

and then:

>> f(2)

ans =

     2

>> f(2,2)

ans =

     4

In Julia:

julia> f(x1) = x1
f (generic function with 1 method)

julia> f(x1,x2) = x1+x2
f (generic function with 2 methods)

julia> f(2)
2

julia> f(2,2)
4
4 Likes
#7

Thereā€™s also optioinal argument and keyword argument combining with dispatch usally cover most of the cases I need to deal with variadic functions.

And if all else failed, you can still declare the function as variadic which @mbaz mentioned in the very first reply alreadyā€¦

#8

And if you want to figure out how many argument a function can accept from outside the function, then no thatā€™s not a property of a function and you generally should not rely on that.

Unless itā€™s for debugging, in which case you can just iterate through the methods.

3 Likes
#9

I donā€™t think you can do that in Matlab either.

#10

Thanks,
This code is useful for me. Perhaps Julia do not have inherit method to get the number of variables of a function. As other people replied, it is not necessary for Julia.

#11

To add to the excellent answers above: strictly speaking functions (eg f) donā€™t have an argument list, methods (eg f(::Any, ::Any, ::Any) do. The distinction between the two is crucial to using Julia efficiently.

Also, unless you are debugging or doing something very advanced, trying to recover this meta-information is usually a sign that the code is not well-designed for Julia.

7 Likes
#12

Thank :+1:

#13

Hi @gangchern!

I also had this question, and @Tamas_Pappā€™s answer put two and two together for me, haha.

Thanks for asking it.

Also, you should mark his answer as the solution so future enquirers will find it easier. :slightly_smiling_face:

#14

Just for completeness, there is a way to access the number of arguments of a particular Method:

f = (x,y) -> x + y
first(methods(f)).nargs  - 1

This is used nicely in the LinearMaps.jl package that certainly qualifies as ā€œsomething very advancedā€ as @Tamas_Papp saidā€¦
I donā€™t understand why the -1 is needed but it worksā€¦
But this is probably not what most Matlab users want when they search for nargin

1 Like
#15

Complementing even more, I would directly translate the given Matlab example

to

julia> function f(x1, x2 = nothing)
           if x2 === nothing
               return x1
           else
               return x1 + x2
           end
       end
f (generic function with 2 methods)

julia> f(2)
2

julia> f(2, 2)
4
2 Likes
#16

This might be a typo, but: Matlab = Matrix Laboratory.

#17

It was a typo. Corrected.

#18

Again, you really donā€™t want to do this. This looks like an XY problem, applying the Matlab solution to Julia, where there are more idiomatic approaches, eg

  1. for a vararg like f(args...), you just want length(args),

  2. for optional arguments, just do that, like @Henrique_Becker shows above,

  3. for the Matlab-style switch nargin, you want to define separate methods,

  4. Matlabā€™s nargin(f) really does not make sense in Julia because of multiple dispatch,

  5. in the remaining 0.1% cases if you are writing code introspection tools, you know what you are doing and need the internals.

6 Likes
#19

Somehow one has to reach that point where ā€œyou knowā€, and searching forums like this can be helpful. The manual itself is very brief about what methods can doā€¦

#20

I think you misunderstand the context: most users never need to learn about internals and introspection of the methods table, so they donā€™t have to reach that point. In fact, using methods in regular code is an anti-pattern; itā€™s for interactive exploration.

If one really, really needs to know these details, they are mostly in the devdocs. Putting them into the manual per se would be misleading.

2 Likes