CODEWITHSUNDEEP
matlabmatrixbinaryxor
Roshni191
Roshni191

Reputation: 79

How to perform XOR in a recursive scenario

I have a 1x5 char matrix. I need to perform a bitwise XOR operation on all the elements in the matrix.If T is the char matrix , I need a matrix T' such that

         T'= T XOR (T-1)'  for all T
             T             for T=1

Let the char matrix be T

   T=['0000000000110111' '0000000001000001' '0000000001001010'  '0000000010111000'  '0000000000101111']
   T'=['0000000000110111' '0000000001110110' '0000000000111100' '0000000010000100' '0000000010101011']

ie; Leaving the first element as such , I need to XOR all the other elements with the newly formed matrix. I tried the following code but I'm unable to get the correct result.

     Yxor1d = [T(1) cellfun(@(a,b) char((a ~= b) + '0'), T(2:end), T'(1:end-1), 'UniformOutput', false)]

I need to perform the XOR operation such that , for obtaining the elements of T'

T' (2)= T(2) XOR T' (1)
T' (3)= T(3) XOR T' (2)

It'll be really helpful to know where I went wrong.Thanks.

Upvotes: 2

Views: 1145

Answers (2)

Hoki
Hoki

Reputation: 11812

Edit: There is a solution without a loop:

T=['0000000000110111';'0000000001000001';'0000000001001010';'0000000010111000' ;'0000000000101111'];

Yxor = dec2bin(bi2de(mod(cumsum(de2bi(bin2dec(T))),2)),16)
Yxor =
0000000000110111
0000000001110110
0000000000111100
0000000010000100
0000000010101011

This uses the fact that you effectively want a cumulative xor operation on the elements of your array.
For N booleans it should be either any one of them or else all of them. So if you do a cumulative sum of each of your bits, the sum should be an odd number for a true answer to 'xor'.

The one liner above can be decomposed like that:

Y = bin2dec(T) ;            %// convert char array T into decimal numbers
Y = de2bi( Y ) ;            %// convert decimal array Tbin into array of "bit"
Y = cumsum(Y) ;             %// do the cumulative sum on each bit column
Y = mod(Y,2) ;              %// convert all "even" numbers to '0', and 'odd' numbers to '1'
Y = bi2de(Y) ;              %// re-assemble the bits into decimal numbers
Yxor = dec2bin(Y,16) ;      %// get their string representation

Note that if you are happy to handle arrays of bits (boolean) instead of character arrays, you can shave off a few lines from above ;-)

Initial answer (simpler to grasp, but with a loop):

You can use the bitxor function, but you have to convert your char array in numeric value first:

T=['0000000000110111';'0000000001000001';'0000000001001010' ;'0000000010111000' ;'0000000000101111'];
Tbin = bin2dec(T) ; %// convert to numeric values

Ybin = Tbin ;  %// pre-assign result, then loop ...
for idx = 2 : numel(Tbin)
    Ybin(idx) = bitxor( Ybin(idx) , Ybin(idx-1) ) ;
end

Ychar = dec2bin(Ybin,16) %// convert back to 16bit char array representation if necessary

Ychar =
0000000000110111
0000000001110110
0000000000111100
0000000010000100
0000000010101011

edited answer after you redefined your problem

Upvotes: 3

rayryeng
rayryeng

Reputation: 104545

You are using cellfun when a cell array is expected as the input. You are using a character array, and what you're actually doing is taking each of those 5 strings and creating a single character array out of them. Chaining those strings together is actually performing a character concatenation.

You probably don't want that. To fix this, all you have to do is make T a cell array by placing {} characters instead of array ([]) characters to declare your characters:

T={'0000000000110111' '0000000001000001' '0000000001001010'  '0000000010111000'  '0000000000101111'};

Because you have edited your post after I provided my answer, my previous answer using cellfun is now incorrect. Because you are using a recurrence relation where you are referring to the previous output rather than input, you can no longer use cellfun. You'll need to use a for loop. There are probably more elegant ways to do it, but this is the easiest if you want to get something working.

As such, initialize an output cell array that is the same size as the input cell array like above, then you'll need to initialize the first cell to be the first cell of the input, then iterate through each pair of input and output elements yourself.

So do something like this:

Yxor1d = cell(1,numel(T));
Yxor1d{1} = T{1};
for idx = 2 : numel(T)
    Yxor1d{idx} = char(double(T{idx} ~= Yxor1d{idx-1}) + '0');
end

For each value i of T', we XOR with the current input at T{i} with the previous output of T'{i-1}.

Use the above and your input cell array T, we get:

Yxor1d = 

  Columns 1 through 3

    '0000000000110111'    '0000000001110110'    '0000000000111100'

  Columns 4 through 5

    '0000000010000100'    '0000000010101011'

This matches with your specifications in your modified post.

Upvotes: 4

Related Questions