Permute matrix columns to find the matrix with biggest trace

Question

I am trying to make a Labview Vi that picks any 3x3 matrix and permutes the columns (not rows!) until it gets the ordenation that has a greatest trace (sum of diagonal elements). The program should also allow a sign change of the elements of one or more columns. If I am not wrong for a given 3x3 matrix and considering the column sign change there are 36 possible matrices, and the program should automatically show the one with greatest trace
For example: 
 1   6    3                                             6   -1   -3
-8  -2    4   should be converted to        -2    8   -4
 3   2   -7                                             2   -3    7
I know it should be a quite simple program, but after spending several hours with L. V. 8.5  I end with a too complicated block diagram that does not work.
Ideally the program should also show of the permutation/sign change that has given the greatest trace but this part I think I am capable to do by myself.
Message Edited by obarriel on 12-28-2009 06:00 PM

Answer 1

Sorry, I pasted the wrong permutation matrix diagram constant for some reason. As you can see, it has only two unique permutations instead of six. Silly! You can easily paste Darin's permutation matrix and it will work correctly.
Here's a more general version that generates all permutations on the fly (LV 8.5). It does a 10x10 in under two seconds (3628800 permutations!).
See if this works better for you.
The permutation algorithm is from wikipedia:
For every number k, with 0 = k < n!, the following algorithm generates a unique permutation of the initial sequence sj, j = 1, ..., n:  
function permutation(k, s) {
     for j = 2 to length(s) {
        swap s[(k mod j) + 1] with s[j]; // note that our array is indexed starting at 1
        k := k / j;        // integer division cuts off the remainder
     return s;
NOTE: Indexing in LabVIEW starts at 0, so the code is changed accordingly.
For larger matrices you'll run out of steam very quickly because the permutations increase with N factorial. I am sure there would be a much more
intelligent algorithm to solve all that in much less time.
Message Edited by altenbach on 12-29-2009 09:31 AM
LabVIEW Champion . Do more with less code and in less time .
Attachments:
MaxTraceCA2.vi ‏27 KB
MaxTraceCA2.png ‏61 KB