Question

I have an array (M) of matrices. I perform an operation on the matrix in the ith position, and it adds three more matrices to my array in the (3i-1), (3i) and (3i+1)th positions. I want to continue this process until I reach the jth position in the array, where j is such that all matrices in the (j+1)th position and onwards have appeared already somewhere between positions 1 and j (inclusive).

EDIT: I’ve been asked to clarify what I mean. I am unable to write code that makes my algorithm terminate when I want it to as explained above. If I knew a proper way of searching through an array of matrices to check if a given matrix is contained, then I could do it. I tried the following:

done = 0;    

ii = 1

    while done ~= 1

    %operation on matrix in ith position omitted, but this is where it goes

        for jj = ii+1:numel(M)

                for kk = 1:ii
                    if M{jj} == M{kk};
                        done = done + 1/(numel(M) - ii);
                        break
                    end
                end
        end

            if done ~= 1
                done = 0;
            end

    ii = ii + 1

    end

The problem I have with this (as I’m sure you can see) is that if the process goes on for too long, rounding errors stop ever allowing done = 1, and the algorithm doesn’t terminate. I tried getting round this by introducing thresholds, something like

while abs(done - 1) > thresh

and

if abs(done - 1) > thresh
    done = 0;
end

This makes the algorithm work more often, but I don’t have a ‘one size fits all’ threshold that I could use (the process could continue for arbitrarily many steps), so it still ends up breaking.

What can I do to fix this?

Thanks

Answer 1

Why don’t you initialize done at 0, keep your while done==0 loop, and instead of computing done as a sum of elements, check if your condition (finding if the matrix already exists) is verified for all jj, something like this:

alldone=zeros(numel(M)-ii,1);

for jj = ii+1:numel(M)

        for kk = 1:ii
            if isequal(M{jj},M{kk})
                alldone(jj-ii) = 1
                break
            end
        end
end
done=prod(alldone);

There is probably a more elegant way to code this, though.
For instance, you could add early termination:

while done==0
done=1;
for jj = ii+1:numel(M)
    match_success=0;
    for kk = 1:ii
        if isequal(M{jj},M{kk})
            match_success=1;
            break
        end
    end
    if match_success==0
        done=0;
        break;
    end
end
end

At the beginning of each loop, the algorithm assumes it is going to succeed and stop there (hence the done=1). Then for each jj, we create a match_success which will be set to 1 only if a match is found for M{jj}. If the match is found, we break and go to the next j. If no match if found for j, match_success is left to 0, done is initialized to 0 and the while loop continues. I haven’t checked it, but I think it should work.

This is just a simple tweak, but again, more thought can probably speed up this whole code a lot.