I am trying to solve following error in my code, Error using .* Matrix dimensions must agree.

 clear all;
 EbN0_dB = 0:2.5:30;
 EbN0 = 10.^(EbN0_dB/10); % convert from dB scale

 Analytical_BER_ASK = Q(sqrt(EbN0)); % BER of ASK
 Analytical_BER_BPSK = Q(sqrt(2*EbN0)); % BER of QPSK and BPSK

 L = 1000;
 Numerical_BER_ASK = zeros(1,length(EbN0));
 Numerical_BER_BPSK = zeros(1,length(EbN0));
 for i=1:length(EbN0) % run simulation for each EbN0 value
    ASK_error = 0;   % to count number of error with ASK
    BPSK_error = 0;  % to count number of errors with BPSK
    noOfL = 0;       % to keep track number of bit sequences

    while BPSK_error < 100
        N0 = 1/(EbN0(i)); % with Eb = 1, N0 = 1/(EbN0)

        s = randi([0,1],1,L); % random bit sequence of length L

        ASK_TX_signal = s*sqrt(2); % ASK modulated signal
        BPSK_RX_signal = 2*s - 1;  % BPSK modulated signal

        noise = sqrt(N0/2) * randn(1,L); % Gaussian noise;

        % Generate the fading channel, it's a Gaussian random variables
        channel = sqrt(1/2)*(randn(1,L) + 1i*randn(1,L));

        ASK_RX_signal = channel.*ASK_TX_signal + noise; % receive ASK signal
        BPSK_RX_signal = channel.*BPSK_RX_signal + noise; % receive BPSK signal

        % Before doing demodulation, you do equalizer and co-phases the
        % channel
        ASK_RX_signal = conj(channel).*ASK_RX_signal;
        BPSK_RX_signal = conj(channel).*BPSK_RX_signal;

        % demodulate ASK signal with threshold at sqrt(2)/2
        ASK_s = double(ASK_RX_signal > sqrt(2)/2);
        % demodulate BPSK signal with thresshold at 0;
        BPSK_s = double(BPSK_RX_signal > 0);

        ASK_error = ASK_error + sum(ASK_s~=s); % count error with ASK
        BPSK_error = BPSK_error + sum(BPSK_s~=s); % count error with BPSK
        noOfL = noOfL + 1;
    end
    Numerical_BER_ASK(i) = ASK_error/L/noOfL;
    Numerical_BER_BPSK(i) = BPSK_error/L/noOfL;
 end

 A_ASK = semilogy(EbN0_dB,Analytical_BER_ASK,'-');
 hold on
 A_BPSK = semilogy(EbN0_dB,Analytical_BER_BPSK,'--');
 N_ASK = semilogy(EbN0_dB,Numerical_BER_ASK,'o');
 N_BPSK = semilogy(EbN0_dB,Numerical_BER_BPSK,'s');
 xlabel('Eb/N0 in dB');
 ylabel('BER');
 legend([A_ASK A_BPSK N_ASK N_BPSK],'Analytical ASK','Analytical BPSK',...
    'Numerical ASK','Numerical BPSK');

Answer 1

[Cedric]

If you got this code from someone else and it should be working (because it used to work with the exact same parameters), my guess is that the person wrote it for/on a recent version of MATLAB that supports implicit expansion, and you are trying to run it on an older version that requires explicit calls to BSXFUN for performing operations with implicit expansion (..).

On recent versions you can do this:

 >> x = 1 : 5
 x =
     1     2     3     4     5

 >> Y = repmat( 21:25, 4, 1 )
 Y =
    21    22    23    24    25
    21    22    23    24    25
    21    22    23    24    25
    21    22    23    24    25

 >> x .* Y
 ans =
    21    44    69    96   125
    21    44    69    96   125
    21    44    69    96   125
    21    44    69    96   125

where you can observe an automatic expansion of x along dim 1, otherwise we could not perform this element-wise multiplication. On former version of MATLAB, we had to proceed as follows:

 >> bsxfun( @times, x, Y )
 ans =
    21    44    69    96   125
    21    44    69    96   125
    21    44    69    96   125
    21    44    69    96   125

If this is what is happening (based on your screenshots it could be), then you have to update the code and implement relevant calls to BSXFUN. For the line where you have the error, this should be:

 BPSK_RX_signal = bsxfun( @times, channel, BPSK_RX_signal ) + noise; % receive BPSK signal

where both channel and noise are 8x1000 and BPSK_RX_signal is 1x1000.

If the code has never worked before, the error may be elsewhere.

EDIT: I don't understand how channel and noise can be 8x1000 with this code by the way, so the error should be elsewhere.

[MOHINI MODI]

Hello Cedric,

Thank you very much for you help. Yes code is working on new version. But i am trying to run it on MATLAB R2015 version and i am getting error.

[Cedric]

Hello Mohini,

I still don't understand how you can have multiple rows (8) in channel and noise with this code (as N0 is a scalar and you are generating row 1xL vectors above). Yet, if what I mention is really the problem, the automatic expansion came with R2016b; this is better described here:

https://blogs.mathworks.com/loren/2016/10/24/matlab-arithmetic-expands-in-r2016b/

[MOHINI MODI]

I am trying to implement BSXFUN for line 51 in my code. But i am getting same error. I am not understanding how to implement it: BPSK_RX_signal = bsxfun( @mtimes, BPSK_RX_signal,(channel_power == channel_max));

[Cedric]

EDIT: I corrected my answer @mtimes -> @times, but it was not the issue.

If the expansion was an issue, my guess is that it was not the only one and that answering how you could have 8x1000 arrays in a code (above) that should not be building such arrays, is key to solving your issue.

The expansion cannot work on the line where your error is, and you don't understand what it does. In my example above, the element-wise multiplication (operator .* or function times) cannot work between x and Y, because they don't have the same size/dimension (we cannot match each element of x and each element of Y based on their position and perform multiplications: x is a row vector, Y is an array). But if we need to have an element-wise multiplication of x width each row of Y (notice that x and rows of Y have the same size/dimension), we can perform it with:

 bsxfun( @times, x, Y )  % And simply x .* Y from R2016b on.

where the first argument is a handle on the function that we want to apply (here times) and BSXFUN detects that x and Y have a common dimension (2) and expands x along dimension 1 to match the number of rows of Y and perform the operation element-wise on two arrays with matching dimensions.

Now in the line associated with your new error, there is no matrix multiplication, it is logical indexing. Assuming that channel_max is a scalar, the following:

 channel_power == channel_max

is an array of logicals with the same size as channel_power. I have no idea about the dimensions of all these variables that appear, but the size of the array of logicals should match the size of the array that is indexed, BPSK_RX_signal. This isn't a technical obligation, but I'd say that it is very unlikely that the person who wrote this code implemented a valid logical indexing with mismatching arrays.

It is difficult to know what is wrong without being able to run code and debug. If I were you though, I would focus on understanding why in your first question the arrays that I mentioned above are 8x1000 and not 1x1000, and whether it is valid or not.