Tukukkk

For a project I have a list of possible activation functions to choose from, depending on whats chosen in the configuration.
i want these to all be g() so that g is a changeable function.
Also in each function file, i have defined the derivative as a function Dg():

function [g Dg]  = identity(x)

g  = x;

Dg = 1

end

I can refer to the first output of the function:

g = @identity

but how do i define Dg() in a similar way?

You are wrong, you are not referring to the first output of the function, you are referring to the entire function like that. in your example, g becomes identity.

You can test this by doing:

g = @identity;

[out1,out2]=g(5)

You can rename it as much as you want

mrpotato = @identity;

[out1,out2]=mrpotato(5)

Possibly the fact that when you call a function without brackets in the output it only returns 1 output and in conjunction you named the function the same as the first output mislead you to think you are catching the first output, but this is not the case, you are just copying the entire function and calling it g

@ is an operator to define/reference functions.

Calls to a function with a single output in the expression, such as a=something();, will always return the first output of something(), whether it is a function or a handle to a function.

A workaround would be to make a function designed to return the second (or n-th) output from whatever handle it is given and pipe @identity (or any other handle) through it :

function out=take_second_output(fun,input)

    %fun  : function handle

    %input: value

    [~,out]=fun(input);

end



% More generic version,:

% - works with any number of arguments

% - any of the outputs can be picked

%

% Calling 'a=take_nth_output(fun,n,arg1,arg2,...)' is equivalent to

% '[~,~,...(n-1) times ...,a] = fun(arg1,arg2,...)'

function out=take_nth_output(fun,n_out,varargin)

    %fun  : function handle

    %n_out: index of the output to be returned

    out_tmp=cell(n_out,1);

    out_tmp{:} = fun(varargin{:});

    out = out_tmp{n_out};

end



% define function handle d

d = @identity;

% define Dg as an anonymous handle

Dg = @(x) take_second_output(@identity,x);

Dg_generic = @(x) take_nth_output(@identity,2,x);

If you want to obtain functions g and Dg, you probably want to return function handles instead. Something like this:

function [g,Dg] = identity

   g  = @(x) x;

   Dg = @(x) 1;

end

Now this line:

[g,Dg] = identity;

will give you two functions, which you can use as:

y = g(x);

dy = Dg(x);

A more complicated example, the actual functions returned here are not all that complex, but this shows the mechanics. You can create complicated functions with tunable parameters, flow control, etc.:

function [g,Dg] = complicated(scale)

   g  = @func;

   Dg = @deriv_func;



   function y = func(x)

      y = cos*scale(x);

   end

   function y = deriv_func(x)

      y = -scale*sin(scale*x);

   end

end

Similarly to before, you now do:

[g,Dg] = complicated(4.7);

to get your function handles. The 4.7 will be “embedded” in those handles, meaning that it affects the meaning of the functions g and Dg.