MATLAB: Though the code is pretty simple, still the value of theta remains 0 every time I execute the results with different values of w,x,y,z,u and v. The value of theta doesn’t change anytime.

homework

w=30; x=60; y=45; z=90; u=35; v=75;
% "w,x,y,z are known" and "u and v are free choices". %
a12_c=cosd(w); a12_s=sind(w); a13_c=cosd(x); a13_s=sind(x);
b12_c=cosd(y); b12_s=sind(y); b13_c=cosd(z); b13_s=sind(z);
c12_c=cosd(u); c12_s=sind(u); c13_c=cosd(v); c13_s=sind(v);
A=[1 0 1 0 -1 0; 0 1 0 1 0 -1; a12_c -a12_s c12_c -c12_s -b12_c b12_s;...
    a12_s a12_c c12_s c12_c -b12_s -b12_c; a13_c -a13_s c13_c -c13_s -b13_c b13_s;...
    a13_s a13_c c13_s c13_c -b13_s  -b13_c];
B=[1 0 1 0 1 0]';
% disp(A); disp(B);
X=A\B;  % X=[P Q R S T U]'; 
disp('The required matrix is:')
disp(X);
P=X(1,1); Q=X(2,1); R=X(3,1); S=X(4,1); T=X(5,1); U=X(6,1);
a=sqrt(P.^2 + Q.^2); b=sqrt(R.^2 + S.^2); c=sqrt(T.^2 + U.^2);
disp('The link lengths are:');
fprintf('a= %.3f \n',a); fprintf('b= %.3f \n',b); 
fprintf('c= %.3f \n',c); fprintf('d= 1\n');
theta1_1_a= acosd(P/a); theta1_1_b=-theta1_1_a; 
theta1_2_a= asind(Q/a); theta1_2_b=180-theta1_2_a;
theta=0;
fprintf('theta1_1_a= %.2f \n',theta1_1_a);
fprintf('theta1_1_b= %.2f \n',theta1_1_b);
fprintf('theta1_2_a= %.2f \n',theta1_2_a);
fprintf('theta1_2_b= %.2f \n',theta1_2_b);
if theta1_1_a==theta1_2_a || theta1_1_a==theta1_2_b
    theta=theta1_1_a;
    fprintf('theta= %.2f\n', theta1_1_a);
elseif (theta1_1_b==theta1_2_a) || (theta1_1_b==theta1_2_b)
    theta=theta1_1_b;
end
fprintf('theta= %.2f\n', theta);

Best Answer

Without even trying to exceute your code...

You set theta to zero.

The value of theta will ONLY ever be changed if a test is satisfied for exact equality between two floating point numbers. So tests like this:

if theta1_1_a==theta1_2_a || theta1_1_a==theta1_2_b

Now, l'll look at the result of your code.

[theta1_1_a, theta1_2_a]
ans =
          64.4196851608345         -64.4196851608345
>> [theta1_1_a, theta1_2_b]
ans =
          64.4196851608345          244.419685160834

So that test must fail.

Then you have an elseif clause.

elseif (theta1_1_b==theta1_2_a) || (theta1_1_b==theta1_2_b)

Is it satisfied?

[theta1_1_b, theta1_2_a]
ans =
         -64.4196851608345         -64.4196851608345

Gosh, it looks like they are the same numbers. Are they really the same?

[theta1_1_b == theta1_2_a]
ans =
  logical
   0
   
theta1_1_b - theta1_2_a
ans =
       1.4210854715202e-14

As you can see, they are not in fact identical.

NEVER TEST FOR EXACT EQUALITY BETWEEN FLOATING POINT NUMBERS. At least not until you truly understand why I just told you not to do so, and you understand when you can expect such a test to be valid. And even then, be careful.

Learn to use tolerances.

Related Solutions

MATLAB: When does randomness enter a shuffled “deck” of coin tosses.

I put together this simple script. In it you will find perhaps the most efficient scheme for a riffle shuffle that I know of, since it can be done as a simple element permutation, just a re-indexing of the elements.

With N = 5e5, thus 1e6 total elements, you should see how fast it is.

timeit(@() B(riffleperm))
ans =
     0.005221

So it would appear I can do nearly 200 such shuffles in one second.

Anyway, read down to the end, and then think about what you see.

%% Will a sequence of riffle shuffles ever produce a truly random sequence? Well, yes. And no. 
% Consider a sequence of random bits, N zeros, followed by N ones. Now
% perform a perfect riffle shuffle. Repeat as often as you wish. The final
% sequence of bits after S such perfect riffle shuffles is perfectly
% deterministic, so not at all random. It may appear to be pseudo-random.
% It may approach the appearance of randomness at some level. We can test
% for things like that.
N = 5e5;
B0 = floor((0:2*N-1)/N);
 
% riffleperm has the property that B(riffleperm) will be a perfect riffle
% shuffle.
riffleperm = zeros(1,2*N);
riffleperm(1:2:end) = 1:N;
riffleperm(2:2:end) = N+1:2*N;
 
%% Now, perform S such riffleshuffles. For example, with S = 10, we might do this:
S = 10;
B = B0;
for ns = 1:S
  B = B(riffleperm);
end
 
%% How random is B, after 10 such shuffles?
% One simple test might be to ask how many 1s are in the first half of the
% sequence. While a perfectly random sequence might seem to have exactly
% 1/2 of the 1's that would be wrong. In fact, the distribution of the
% number of 1's in either half of a truly random sequence would follow a
% binomial distribution.
sum(B(1:N))
ans =
      250000
      
% In fact, that is a highly unlikely event. It is not at all random, that
% exactly 50% of the elements in the first half are 1, that is, IF the
% sequence was truly random. Worse, try the same thing for ANY number of
% perfect riffle shuffles.
S = 20;
B = B0;
for ns = 1:S
  B = B(riffleperm);
  disp([ns,sum(B(1:N))])
end
 
           1      250000
           2      250000
           3      250000
           4      250000
           5      250000
           6      249984
           7      250000
           8      250000
           9      250000
          10      250000
          11      250000
          12      249996
          13      250000
          14      250016
          15      250000
          16      250002
          17      250000
          18      249998
          19      249992
          20      249996
          
% Surprisingly, a fair number of those shuffles end up with exactly 50% of
% the elements 1 in each half o the sequence. Perhaps mor interesting yet,
% is to look at the number of elements in either half after EXACTLY 180
% such perfect riffle shuffles.
S = 180;
B = B0;
for ns = 1:S
  B = B(riffleperm);
end
sum(B(1:N))
ans =
     0
     
%% Yes, after 180 perfect riffle shuffles, that sequence of 1e6 bits
% really has returned to its original order. Had you started with
%   B = 1:1e6;
% you would indeed find the final sequence in B is perfectly 1:1e6 again.
% 180 perfect riffle shuffles are sufficient there to completely and
% exactly restore the sequence of 1:1e6.
B = 1:2*N;
S = 180;
for ns = 1:S
  B = B(riffleperm);
end
isequal(B,1:2*N)
ans =
  logical
   1

Now you should recognize something interesting. That is, after 1 perfect riffle shuffle, we will have identically the same sequence as 181 perfect riffle shuffles, since 180 shuffles returned us to the starting position. In fact, every 180 such perfect riffle shuffles are sufficient to return the sequence to the exact start point.

The most interesting question in all of this might be to show that for N = 5e5, thus a total sequence of 1e6 such elements, that 180 is the magic number of perfect riffle shuffles to restore the original sequence, when N = 5e5.

https://math.hmc.edu/funfacts/perfect-shuffles/

That probably would get more deeply into group theory then we want to go here.

MATLAB: Nested loops of different dimension without using “for loops”

ct = cosd(tilt);
p1 = cosd(15.*h(:))*cosd(delta);
sb = bsxfun(@plus,cosd(Lat)*p1,sind(Lat)*sind(delta));
cb = cosd(asind(sb));
phi_s  = asind(bsxfun(@rdivide,p1,cb));
costheta = cb.*cosd(phi_s-phi_c).*sind(tilt)+sb.*ct;
s = size(sb);
I_bc = reshape(DNI,s).*costheta;
I_rc = reshape(GHI,s)*reflectance*(1-ct)/2;
I_dc = reshape(DHI,s)*(1+ct)./2;
I_c = I_bc+I_dc+I_rc;

ADD

I_c_out = I_c(:);

Best Answer

Related Solutions

MATLAB: When does randomness enter a shuffled “deck” of coin tosses.

MATLAB: Nested loops of different dimension without using “for loops”

Related Question