How to write code for Assignment problem using GA matlab tool.

You cannot simultaneuously optimize two separate things at once. Except that you can, but you need to use ideas from the field of multi-criteria optimization. In MATLAB, there is the tool fgoalattain, except that it cannot handle integer constraints.

Next, as pointed out by @Sam Chak, this is a linear problem, except that you cannot use a tool like intlinprog to solve that problem. (You would want intlinprog, because of the integer constraints. linprog has no ability to solve integer problems.)

Finally, since you have only 16 total variables, each of which can take on only two values, the simplest solution is to just evaluate the objectives for all possible sets of the parameters. That would look as if you have 65536=2^16 possible combinations. But as importantly, the constraints make it obvious that in fact, you don't have that many ways to do this. In fact, your constraints force this to be a problem where all of the matrices must be permutation matrices. There are only 24 possible 4x4 permutation matrices. We can find all 24 of them as permutations of the 4x4 identity matrix. So start with the 4x4 identity.

X = eye(4);
PermsList = perms(1:4)
PermsList = 24×4
   3     2     1
   3     1     2
   2     3     1
   2     1     3
   1     3     2
   1     2     3
   4     2     1
   4     1     2
   2     4     1
   2     1     4

As I said, 24 of them. We can find all admissable permutations as:

X = permute(reshape(X(PermsList,:),[24 4 4]),[2 3 1]);

For example, one such admissable permutation is:

X(:,:,5)
ans = 4×4
     0     0     0     1
     1     0     0     0
     0     0     1     0
     0     1     0     0

As you can see, each of them satisfy all of your constraints.

X
X = 
X(:,:,1) =

   0     0     1
   0     1     0
   1     0     0
   0     0     0


X(:,:,2) =

   0     0     1
   0     1     0
   0     0     0
   1     0     0


X(:,:,3) =

   0     0     1
   1     0     0
   0     1     0
   0     0     0


X(:,:,4) =

   0     0     1
   1     0     0
   0     0     0
   0     1     0


X(:,:,5) =

   0     0     1
   0     0     0
   0     1     0
   1     0     0


X(:,:,6) =

   0     0     1
   0     0     0
   1     0     0
   0     1     0


X(:,:,7) =

   0     1     0
   0     0     1
   1     0     0
   0     0     0


X(:,:,8) =

   0     1     0
   0     0     1
   0     0     0
   1     0     0


X(:,:,9) =

   0     1     0
   1     0     0
   0     0     1
   0     0     0


X(:,:,10) =

   0     1     0
   1     0     0
   0     0     0
   0     0     1


X(:,:,11) =

   0     1     0
   0     0     0
   0     0     1
   1     0     0


X(:,:,12) =

   0     1     0
   0     0     0
   1     0     0
   0     0     1


X(:,:,13) =

   1     0     0
   0     0     1
   0     1     0
   0     0     0


X(:,:,14) =

   1     0     0
   0     0     1
   0     0     0
   0     1     0


X(:,:,15) =

   1     0     0
   0     1     0
   0     0     1
   0     0     0


X(:,:,16) =

   1     0     0
   0     1     0
   0     0     0
   0     0     1


X(:,:,17) =

   1     0     0
   0     0     0
   0     0     1
   0     1     0


X(:,:,18) =

   1     0     0
   0     0     0
   0     1     0
   0     0     1


X(:,:,19) =

   0     0     0
   0     0     1
   0     1     0
   1     0     0


X(:,:,20) =

   0     0     0
   0     0     1
   1     0     0
   0     1     0


X(:,:,21) =

   0     0     0
   0     1     0
   0     0     1
   1     0     0


X(:,:,22) =

   0     0     0
   0     1     0
   1     0     0
   0     0     1


X(:,:,23) =

   0     0     0
   1     0     0
   0     0     1
   0     1     0


X(:,:,24) =

   0     0     0
   1     0     0
   0     1     0
   0     0     1

Now you could merely loop through every possible plane of that array. Test them all, taking the one that makes you happy.

Regardless, you will still need to decide how to simultaneously choose between two disparate objectives, because the set that optimizes one will not be the set that optimizes the other. You will need to decide how to combine the two objectives into one.

Would you want to use GA to do this? Why in the name of god and little green apples would you do that, or even use intlinprog, when there are only 24 such possible matrices to consider?