Summation of functions in a loop

Hi there, I would like to create functions and then sum them up in a loop. Then use an optimizer to find the minimum of the summation. The functions are the same but I need them to have independent variables.

for example: I need a "matrix" of functions

A=[@(x)(x(1)-S(1))^2, @(x)(x(2)-S(2))^2,..., @(x)(x(n)-S(n))^2]

,where S a (1xn) matrix. Then summing all of the above functions to get the minimum

x0 = [0,0,...n];
x = fminsearch(sum(A(:)),x0)

The above code does not work but I am just posting it so you get a better idea of what I am looking for. Thank you

Answer 1

[Stephen23]

Creating an array of functions is a red herring. You just need one simple array, inside one function:

>> fun = @(x) sum((x-5).^2);
>> x0 = [0,0,0,0];
>> fminsearch(fun,x0)
ans =
   4.9997   5.0001   5.0001   5.0002

If you really want each "function" to be different, then you still only need one matrix inside one function:

>> fun = @(x) sum([(x(1)-3)^2,(x(2)-5)^2,(x(3)-8)^2,(x(4))^2]);
>> x0 = [0,0,0,0];
>> fminsearch(fun,x0)
ans =
  2.9998e+000  4.9999e+000  7.9998e+000  -1.3034e-004

Trying to create an array of functions is possible (just put them into a cell array), but will likely be a total waste of your time. After all, fminsearch only accepts one function, so why not simply define one function ?

[Spyros Polychronopoulos]

You are right. I just corrected what I want. It is not the same function unfortunately.

A=[@(x)(x(1)-5)^2, @(x)(x(2)-8)^2,..., @(x)(x(n)-2)^2]

[Spyros Polychronopoulos]

could I create this:

fun = @(x) sum([(x(1)-3)^2,(x(2)-5)^2,(x(3)-8)^2,(x(4))^2]);

with a loop? cause I have lots of variables.

Maybe something like:

for k=1:1:10000
 fun = @(x) sum((x(k)-A1(k))^2); 
end

For A1 a (1x10000) matrix. But the problem here is that there is nothing to sum before you define the functions.

[Stephen23]

@Spyros Polychronopoulos: your loop shows that x and A1 are both indexed by k. You do not need a loop, you can simply write vectorized code, where you operate on the complete matrices at once:

fun = @(x) sum((x-A1).^2);

This assumes that x and A1 have compatible sizes. Note that my answer showed a complete working example of this. As far as I can tell, what you are trying to do serves no obvious purpose other than to make the code much slower and more complex. You are trying to do this:

>> A = [2,4,8,16];
>> for k = 1:numel(A), C{k}=@(x)(x(k)-A(k)).^2; end % lots of functions!
>> fun = @(x)sum(cellfun(@(f)f(x),C)); % slow and complex cellfun
>> x0 = [0,0,0,0];
>> fminsearch(fun,x0)
ans =
    1.9997    4.0004    7.9999   16.0003

Whereas I am advising you to write much simpler and more efficient vectorized code:

>> A = [2,4,8,16];
>> x0 = [0,0,0,0];
>> fminsearch(@(x)sum((x-A).^2),x0)
ans =
    1.9997    4.0004    7.9999   16.0003

Note that the output is exactly the same. Why do you need to write such complex, slow code with all of those functions generated in a loop?

[Spyros Polychronopoulos]

Thank you very much @Stephen Cobeldick for your input!

[Spyros Polychronopoulos]

Stephen Cobeldick could you maybe advice on this one as well?:

https://uk.mathworks.com/matlabcentral/answers/366118-calculations-with-functions-in-cells

[Jay Heng]

https://www.mathworks.com/matlabcentral/answers/364747-summation-of-functions-in-a-loop#comment_500577

Hi, may i please ask on the third line, i dont understand why do we define @(f)f(x) , the variable for this example is x, why do we still have to define another variable f.

[Stephen23]

" i dont understand why do we define @(f)f(x) , the variable for this example is x, why do we still have to define another variable f."

Because each individual function in that cell array needs to be called with the same array x, and that is what that anonymous function does when it is called by cellfun. Alternatively a simple loop would also work. I strongly recommend avoiding doing either of those and instead using more efficient arrays (just like MATLAB was designed for, and just like I showed).

[Jay Heng]

Hi Stephen, thanks for getting back to me. Yes i am trying my best to follow along with your discussion with Spyros. But i still have some doubts, would you mind clarifying.

"Because each individual function in that cell array needs to be called with the same array x"

Did you mean to say that x is an array? I thought the only cell array is A.

Also i saw that you offered the following vectorised code:

fun = @(x) sum([(x(1)-3)^2,(x(2)-5)^2,(x(3)-8)^2,(x(4))^2]);

I dont understand how does the indexing x(1) works, since your code did not initialise x as vector.

Why not just @x sum([ (x-3)^2, (x-5)^2, (x-8)^2...]) .

Hope that you help to clarify this for me. Thank you.

[Stephen23]

"Did you mean to say that x is an array? I thought the only cell array is A."

The anonymous functions defined in the original question all accept the same input array and all return a scalar output. The OP named this input array x, so I used the same name. In this case the array is numeric (remember that numeric scalars, numeric vectors, numeric matrices are not different data types in MATLAB, they are all just numeric arrays of different sizes).

"I dont understand how does the indexing x(1) works, since your code did not initialise x as vector."

Actually it does. The second input argument provided to fminsearch exactly defines the size of the numeric array provided to the function it calls. You can clearly see in the original question that this array has an arbitrary size.

"Why not just @x sum([ (x-3)^2, (x-5)^2, (x-8)^2...]) "

Because that is not what the OP wanted. The OP clearly understood that x is an array and wanted slightly different operations to different elements of that array. What you proposed applies those operations to all of the elements of the numeric array. Not the same thing at all. Try it and see.

[Jay Heng]

Alright i think i finally got it, OP wanted a multivariable function with variables x1, x2.. xn. The indexing of x(1), x(2).. x(n) are all meant to faciliate the passing of the elements in x0 = [0 0 0 0] to the respective x(1), x(2).. x(4) for the fminsearch function. Thank you very much for your clarification!

Can you please explain abit more about the expression cellfun(@(f)f(x)...) without the sum function applied to the overall expression.

" fun = @(x)sum(cellfun(@(f)f(x),C)); % slow and complex cellfun "

I understand that cellfun applies the first argument(a function handler) to each element in C and combine them into a vector. But i do not understand how does matlab intepret applying f(x) to each of the functions of x(1), x(2).. x(n) in C. The matlab documentation for cellfun is that the first argument is some defined function, like sin, or mean, but in this case we do not have an explicitly defined f(x), so how does matlab intepret @(f)f(x) applied to each element in C. Thank you very much thus far for your clarification for me, it helped me alot.

[Stephen23]

"i do not understand how does matlab intepret applying f(x) to each of the functions of x(1), x(2).. x(n) in C"

Note that all of the functions in C accept the same input x. Internally they might only refer to some specific elements of x, but they are all functions of x.

"The matlab documentation for cellfun is that the first argument is some defined function, like sin, or mean, but in this case we do not have an explicitly defined f(x)..."

The cellfun documentation states that its first input argument must be a function handle. A function handle can be a handle to a function, e.g. @mean, @sin, or it could be a handle to an anonymous function:

https://www.mathworks.com/help/matlab/function-handles.html

In this case, the first input to cellfun is this anonymous function:

@(f)f(x)

All that does is evaluate its input argument f using the array x. Lets try it:

>> x = [-pi/2,0,+pi/2];
>> baz = @(f)f(x);
>> baz(@sin)
ans =
  -1   0   1

In this case we used our little anonymous function baz to evaluate just one function handle @sin, but the OP had multiple function handles that they wanted to evaluate. Multiple function handles are scalar only (there is no array form of them) and so must be stored in a container array, e.g. a cell array or a structure. So I used a cell array to store them:

  C = {@sin,@mean,@sqrt};

Given that cell array, how can we evaluate those functions all using the same array? One way would be to use a loop:

for k = 1:numel(C)
    f = C{k};
    f(x)
end

or the equivalent using cellfun: for each function handle in C, how do we evaluate it with input x? Using baz.

In any case, this is a very inefficient approach for the original task: the simple and efficient approach is to use array operations, just like I showed in my answer (and several comments).

[Walter Roberson]

fun = @(x)sum(cellfun(@(f)f(x),C)); % slow and complex cellfun

The @(x) starts the definition of an anonymous function that is to have a single parameter that is to be known as x. That is followed by an expression, which is built into the anonymous function for execution. Everywhere in the expression that x appears (that is not "shadowed" by a different definition), at run-time the x is to be replaced by whatever was passed as the first parameter to the anonymous function. The handle to the anonymous function will be assigned to the variable fun

The body of the anonymous function involves sum() of some values; in particular the vector or array of values returned by a call to cellfun() .

The call to cellfun() is cellfun(@(f)f(x),C) . That call has an anonymous function definition inside it, @(f)f(x) . Every time that anonymous function stored in fun is executed, when the cellfun() is executed, a new anonymous function @(f)f(x) is built.

The logic is not

temp_inner_function = @(f)f(x)
fun = @(x)sum(cellfun(temp_inner_function,C))

That would build a single anonymous function and invoke the one function whenever fun is invoked, which is not what happens. It is important for this purpose that each time that cellfun(@(f)f(x),C) is executed, that a new anonymous function is created.

The reason it it is important that a new anonymous function is created for use by cellfun() during the execution of fun, is that when you create an anonymous function and the body of the function involves variables that are not the parameters, then the current value of those variables at the time the function is built are copied into the function handle. In the case of @(f)f(x), the value of x at the time the function is built is copied into the function handle that is being created. What is the value of x? Well since you are inside the body of a @(x) definition, the value of x will be whatever was passed as the first parameter into fun.

So, the cellfun(@(f)f(x),C) part is building an anonymous function that binds in whatever was passed as the first parameter to fun, as the value to be passed to f. And what is f? Well, because of the @(f) part, f is the first parameter that was passed to that local anonymous function. What is the first parameter that will be passed? You are inside a cellfun() and the logic of cellfun(HANDLE, EXPRESSION) (that does not have 'uniform', 0) is

for K = 1 : numel(EXPRESSION)
    temp_result(K) = HANDLE(EXPRESSION{K});
end
cellfun_result = reshape(temp_result, size(EXPRESSION));

What is being passed as the EXPRESSION to cellfun()? C is being passed. What is C? Refer back to "the body of the function involves variables that are not the parameters, then the current value of those variables at the time the function is built are copied into the function handle. In the case of @(f)f(x), the value of x at the time the function is built is copied into the function handle that is being created" . So the environment is searched for C, and its value from the lines

for k = 1:numel(A), C{k}=@(x)(x(k)-A(k)).^2; end

that C will be built into the function handle that is being created to store into fun. C is a cell array of handles to anonymous functions. Following the above logic for what cellfun does, we can see that the cellfun(@(f)f(x),C) call is going to be accessing each entry inside the cell C in turn, and passing that as the value f to the anonymous function @(f)f(x) , where it is going to be invoked as a function on the value of x that was bound into the function handle as designating whatever was passed as the first parameter to fun.

The effect is as if you had done:

function sum_C_of_x(x, C)
for K = 1 : numel(C)
    temp_result(K) = C{K}(x);
end
sum_C_of_x = sum(temp_result);
end

and had invoked

fun = @(x) sum_C_of_x(x,C);
fminsearch(fun, x0)

[Jay Heng]

Thank you very much Stephen for your example and Walter for your detailed explanations, it is much clearer now! Good day to both of you.

Answer 2

[KL]

I'm not quite clear, you probably want,

 A = @(x) sum((x-5).^2)

If you really intend to create array of functions, then

 A = {@(x)(x(1)-5)^2;
     @(x)(x(2)-5)^2;
     @(x)(x(3)-5)^2;
      ...};

more here: https://de.mathworks.com/help/matlab/matlab_prog/anonymous-functions.html

[Spyros Polychronopoulos]

I tried

 A = @(x) sum((x-5).^2)

But this will encounter for the same x. I need to have f(x1), f(x2),... and sum them up. So I need the minimum F(x1,x2,...)=sum(f(x1),f(x2),...). x1,x2,... are independent variables.

as for your second answer:

1. I can not create that cell in a loop if i try the below the I just get x(k) in the cell

for k=1:1:10
   A(k)={@(x)(x(k)-5)^2};
end

2. I can not add them all up

sum(A{:})

does not work

[Stephen23]

"I need to have f(x1), f(x2),... and sum them up. So I need the minimum F(x1,x2,...)=sum(f(x1),f(x2),...). x1,x2,... are independent variables."

But to use it with fminsearch the function can only have one input variable. The fminsearch documentation states " fun is a function that accepts a vector or array x and returns a real scalar f." Which is exactly what my answer does.

It seems like you might be confused between the MATLAB use of the word "variable", and the common mathematical usage: a "variable" in MATLAB can be an array, which has lots of values in it. For fminsearch just one array is supplied to the function: it has as many values in it as you need to define your system. If it helps you, every time you see the term "variable" used in MATLAB context just think "array of values".