MATLAB: Stop the for loop

for loopMATLAB

I want to stop a loop when the the modulo 26 of the determinant times a 'number', then use such 'number' to multiply the inverse of a matrix. The code is:

clc, clear;
A=input('Symmetric matrix: ');
format rat;
d=det(A)
Minv=inv(A);
M1=(Minv*d);
for i=1:100
  j=mod(d*i, 26);
  x=i;
  if j==1, break, end
end
x
Z=round(mod((M1*x), 26))

However I can't make the for loop to stop when the value of 'j' becomes 1 and use the value of 'x' to multiply the matrix; every time the value of x is the final value of 'i', in this case 100.

Best Answer

Time for the most basic of debugging practises...

After you calculate j, put in the following line of code:

disp(j);

Now, run your loop.

I'm willing to bet that j is either always even (because d is even), or is a sufficiently fractional non-integer.

When you work out what's happening and fix it, then consider the following. From a 'performance' perspective (well, really it's about not doing unnecessary things), just save the value into x once:

x = [];
for i = 1:100
  if mod(d*i,26) == 1
    x = i;
    break;
  end
end
if isempty(x)
  disp('Not found');
end

Doesn't really matter here, but it's worth getting into the habit of recognising some repeated calculations as being pointless. Call it "eco-coding". =)

Related Solutions

MATLAB: For loop isn’t working, unsure as to why

I think you meant for this to be a double for loop. As coded, you only have one for loop and j is a vector. E.g., is this what you meant?

for i = 1:35;
   for j = 1:43;
      if lut(i,j) == 1
          forrest(i,j) = D10weight(i,j);
      end
      if lut(i,j) == 2
          shrub(i,j) = D10weight(i,j);
      end
      if lut(i,j) == 3
          sav(i,j) = D10weight(i,j);
      end
      if lut(i,j) == 4
          grass(i,j) = D10weight(i,j);
      end
      if lut(i,j) == 5
          agri(i,j) = D10weight(i,j);
      end
    end
 end

MATLAB: Help with dec2bin conversion

You are trying to solve what is essentially a very difficult problem when using floating point arithmetic. First, the number 0.13 isn't represented exactly as 0.13 in IEEE double since that exact number is not in the double precision floating point set. This is the exact decimal equivalent of the number that is stored:

>> num2strexact(0.13)
ans =
0.13000000000000000444089209850062616169452667236328125

So already there is a discrepancy between what you may think you are working with and what you are actually working with.

Second, when you start picking off fractions and multiplying them up by 2 each iteration, all those trailing discrepancies become more and more significant. So any hope of taking this algorithm to the extreme and looking for a pattern in the bits will likely be doomed to failure as the iterations progress.

E.g., take a look at the exact IEEE double precision bit pattern for the number 0.13 using this code:

function double2bits(d)
h = num2hex(d);
n = numel(h);
b = char(zeros(4,n));
for k=1:n
    b(:,k) = dec2bin(hex2dec(h(k)),4)';
end
b = b(:)';
fprintf('Sign bit = %s\n',b(1));
fprintf('Exponent = %s\n',b(2:12));
fprintf('Mantissa = %s\n',['1' b(13:end)]); % add in leading hidden bit
end
>> double2bits(0.13)
Sign bit = 0
Exponent = 01111111100
Mantissa = 10000101000111101011100001010001111010111000010100100

If you break apart the mantissa looking for a repeating pattern you might do this:

10000101000111101011
10000101000111101011
1000010100100

It looks good for the first two patterns, but then breaks down in the last pattern. So any scheme that is trying to find a pattern even using the IEEE double precision floating point bits isn't going to work. And likely any scheme you invent yourself that starts with a floating point value isn't going to work either.

You can come up with some type of test for the code you have (e.g., like the test you have ... testing the last calculated value(j) against all previously saved value elements to see if it is there ... and hence a repeating pattern is starting), but it probably will not work well given that you are starting with floating point values that are not "exact" for the numbers you think you are working with to begin with. So value(j) might be very close to a previous value element, but not exactly the same and hence you would not detect the start of a repeating pattern. Etc.

What one could do is start with two integers, e.g., 13 and 100, and then work with those two integers as a ratio to come up with an algorithm for getting the binary conversion. By working with integers one could come up with an exact algorithm that worked and could detect a repeating pattern with certainty. But that would be a totally different algorithm than the one you are currently working with.

Best Answer

Related Solutions

MATLAB: For loop isn’t working, unsure as to why

MATLAB: Help with dec2bin conversion

Related Question