Sum of all even index elements of a 1D array

This is the code that I have so far to sum all the even index elements of a 1D array:

function [out] = mySumEven(A)

n = length(A);

if n == 1

disp('No numbers in even positions'); % out = 'No numbers in even positions';

out = 0; % added

elseif n == 2

out = A(2);

else

out = A(2) + mySumEven(A(3:n));

end

end

My first question is as follows: Why does it output 'No numbers in even positions' when the length of the array is greater than or equal to three and odd?

Secondly, the problem explains that the recursion relation will be different if the length of the array is odd versus even. From what I can tell the above code should work regardless, but how would I implement braches to handle when the length of the array is odd or even?

[Rik]

Is there a reason you are using a recursive function? Is this because it is homework, or was this your own idea?

Answer 1

[Stephen23]

"Why does it output 'No numbers in even positions' when the length of the array is greater than or equal to three and odd?"

Because you wrote your code to evalute the n==1 case for every vector with an odd number of elements. Consider some vector, lets say with 5 elements, then these are the three function calls:

1. n==5 (user call)
2. n==3 (recursive call)
3. n==1 (recursive call, prints "no numbers in even positions")

If you remove the semi-colon and print n, you will see that every odd-lengthed vector results in a function call where n==1. Lets try it right now:

mySumEven(1:5)

n = 5

n = 3

n = 1

No numbers in even positions

ans = 6

What does your function do when n==1? (hint: it prints something)

The most important step in debugging code is to actually look at what your code is doing, not just relying on what it is doing in your head. Code does not care what you think it is doing, it is your job to look at what it really is doing.

"the problem explains that the recursion relation will be different if the length of the array is odd versus even. From what I can tell the above code should work regardless, but how would I implement braches to handle when the length of the array is odd or even?"

I also don't see why branching would be required: that seems like the kind of thing that could be trivially achieved using indexing, much like you have done.

Note that to make your code more robust, you should also consider what happens with empty arrays.

function [out] = mySumEven(A)
n = length(A)
if n == 1
    disp('No numbers in even positions'); % out = 'No numbers in even positions';
    out = 0; % added
elseif n == 2
    out = A(2);
else
    out = A(2) + mySumEven(A(3:n));
end
end

[Camden Nelson]

Okay I see now when I debug it, but I am unsure how to get the code to only print 'No numbers...' if the array has length one. Would I need a separate base case specifically for when the array length is odd and greater than or equal to three?

[Stephen23]

"I am unsure how to get the code to only print 'No numbers...' if they array only has length one."

Basically you need to tell one function call about some kind of status of previous function calls: where each function call knows e.g. "is this the first call?", or "how many calls occured before this one?".

Probably the simplest approach is to count the function calls, e.g. by passing a counter which increases with each call, and then only print if the counter == 0 (or 1 or whatever you start counting from). Such things are very commonly done with recursive functions. Or add another input argument, which is only used by the recursive calls and then simply count the number of input arguments using NARGIN. Note that these could be spoofed by the user, i.e. are fragile.

Personally I would use slightly different approach, by writing a local function that is called recursively (i.e. the main function is not called recursively). Then you can trivially write the main function to handle any cases such as n==1 or whatever, all other vectors get the recursive function calls (which then don't need any special-case handling). And spoofing is not possible because the main function only has one input.

The other major benefit (which you might come to appreciate later) is that the recursive function will still work even if the Mfile/main function name is changed. I distribute code to other users, I cannot presume that they will keep filenames unchanged, and by uncoupling the recursive function from what the user calls their Mfile I can avoid those potential awkward errors entirely ("I changed the filename, now it won't work, your code is awful!")

[Camden Nelson]

Okay the counter method makes sense to me. Would you be willing to share your approach? Recursion is very unfamiliar to me.

[Stephen23]

"Recursion is very unfamiliar to me."

Recursion is a fickle beast, even for experienced programmers :)

"Would you be willing to share your approach?"

mymain(1)

No numbers in even positions

ans =

     []

mymain(1:4)

ans = 6

mymain(1:5)

ans = 6

% Main function (called by user):
function S = mymain(V)
if numel(V)<2
    disp('No numbers in even positions');
    S = [];
else
    S = myrec(V);
end
end
% Recursive function (called by main function):
function S = myrec(V)
if numel(V)>1
    S = V(2) + myrec(V(3:end));
else
    S = 0;
end
end

Please remember to accept my answer if it helped you, by clicking the accept this answer button.

[Camden Nelson]

This is makes much more sense to me now. Thank you!

[Rik]

One of the caveats of recursive functions is that you can quickly run into problems with the maximum function depth:

mymain(1:1e5) % takes 19GB of memory (on my machine)

While a solution using indexing is much faster and has a negligable memory footprint.