William H. Press

Mentioned 1

The example books published as part of the Numerical Recipes second edition series contain source programs that exercise and demonstrate all of the Numerical Recipes subroutines. Each example program contains comments and is prefaced by a short description of what it does. The books contain all of the old material from the original edition as well as new material from the second edition. They will be valuable for readers who wish to incorporate procedures and subroutines into their own source programs. They are available in both FORTRAN and C.

Mentioned in questions and answers.

I'm looking for some pointers here as I don't quite know where to start researching this one.

I have a 2D matrix with 0 or 1 in each cell, such as:

```
1 2 3 4
A 0 1 1 0
B 1 1 1 0
C 0 1 0 0
D 1 1 0 0
```

And I'd like to sort it so it is as "upper triangular" as possible, like so:

```
4 3 1 2
B 0 1 1 1
A 0 1 0 1
D 0 0 1 1
C 0 0 0 1
```

The rows and columns must remain intact, i.e. elements can't be moved individually and can only be swapped "whole".

I understand that there'll probably be pathological cases where a matrix has multiple possible sorted results (i.e. same shape, but differ in the identity of the "original" rows/columns.)

So, can anyone suggest where I might find some starting points for this? An existing library/algorithm would be great, but I'll settle for knowing the name of the problem I'm trying to solve!

I doubt it's a linear algebra problem as such, and maybe there's some kind of image processing technique that's applicable.

Any other ideas aside, my initial guess is just to write a simple insertion sort on the rows, then the columns and iterate that until it stabilises (and hope that detecting the pathological cases isn't too hard.)

**More details**: Some more information on what I'm trying to do may help clarify. Each row represents a competitor, each column represents a challenge. Each 1 or 0 represents "success" for the competitor on a particular challenge.

By sorting the matrix so all 1s are in the top-right, I hope to then provide a ranking of the intrinsic difficulty of each challenge and a ranking of the competitors (which will take into account the difficulty of the challenges they succeeded at, not just the number of successes.)

**Note on accepted answer**: I've accepted Simulated Annealing as "the answer" with the caveat that this question doesn't have a right answer. It seems like a good approach, though I haven't actually managed to come up with a scoring function that works for my problem.

An Algorithm based upon simulated annealing can handle this sort of thing without *too much* trouble. Not great if you have small matrices which most likely hae a fixed solution, but great if your matrices get to be larger and the problem becomes more difficult.

(However, it also fails your desire that insertions can be done incrementally.)

**Preliminaries**

Devise a performance function that "scores" a matrix - matrices that are closer to your triangleness should get a better score than those that are less triangle-y.

Devise a set of operations that are

*allowed*on the matrix. Your description was a little ambiguous, but if you can swap rows then one op would be`SwapRows(a, b)`

. Another could be`SwapCols(a, b)`

.

**The Annealing loop**

I won't give a full exposition here, but the idea is simple. You perform random transformations on the matrix using your operations. You measure how much "better" the matrix is after the operation (using the performance function before and after the operation). Then you decide whether to commit that transformation. You repeat this process **a lot**.

Deciding whether to commit the transform is the fun part: you need to decide whether to perform that operation or not. Toward the end of the annealing process, you only accept transformations that improved the score of the matrix. But earlier on, in a more chaotic time, you allow transformations that don't improve the score. In the beginning, the algorithm is "hot" and anything goes. Eventually, the algorithm cools and only good transforms are allowed. If you linearly cool the algorithm, then the choice of whether to accept a transformation is:

```
public bool ShouldAccept(double cost, double temperature, Random random) {
return Math.Exp(-cost / temperature) > random.NextDouble();
}
```

You should read the excellent information contained in Numerical Recipes for more information on this algorithm.

**Long story short**, you should learn some of these general purpose algorithms. Doing so will allow you to solve large classes of problems that are hard to solve analytically.

**Scoring algorithm**

This is probably the trickiest part. You will want to devise a scorer that guides the annealing process toward your goal. The scorer should be a continuous function that results in larger numbers as the matrix approaches the ideal solution.

How do you measure the "ideal solution" - triangleness? Here is a naive and easy scorer: For every point, you know whether it should be `1`

or `0`

. Add +1 to the score if the matrix is right, -1 if it's wrong. Here's some code so I can be explicit (not tested! please review!)

```
int Score(Matrix m) {
var score = 0;
for (var r = 0; r < m.NumRows; r++) {
for (var c = 0; c < m.NumCols; c++) {
var val = m.At(r, c);
var shouldBe = (c >= r) ? 1 : 0;
if (val == shouldBe) {
score++;
}
else {
score--;
}
}
}
return score;
}
```

With this scoring algorithm, a random field of 1s and 0s will give a score of 0. An "opposite" triangle will give the most negative score, and the correct solution will give the most positive score. Diffing two scores will give you the cost.

If this scorer doesn't work for you, then you will need to "tune" it until it produces the matrices you want.

**This algorithm is based on the premise that tuning this scorer is much simpler than devising the optimal algorithm for sorting the matrix.**