I wasn’t able to find a combination of widths, which results in any suggested ratio becoming greater than R (or MAX)… the problem with my algorithm is a bad behavior with very few columns (i.e. tables with 1 column..)

Sorting according to the ratios CH[i]/M[i] (ratios of hints to maxima) from largest to smallest would be needed for this to work in the case maximum sizes M[i] are set differently for each column.

There usually aren’t “formulas” (formulas that would be helpful for any programming) that would do what a (pretty much) one-line loop of uhuu does!

What I would really like to know, however, is if anyone can come up with a simple expression for O_i that only uses the 4 basic operations, and maybe the min function.

Good work though, uhuu, I think your sorting-based algorithm is the most efficient one yet.

In that use of the iterative neither of the methods I mentioned earlier are iterative (the stopping time does not depend on the error level, given an input the number of steps is finite, regardless of error). The second approach O(n log n) I mentioned does just one loop over the widths after sorting, assigning each column its optimal value.

basically it is like this:
// M – requested widths
// O – optimal widths
// R – maximum allowed width
// tableWidth

// do sorting
// assuming that M and O are now in the order or descending values of M:
remainingWidth = tableWidth;
remainingRequested = sum(M);
// doing loop starting from the largest:
for (i=0; i<n; i++) {
O[i] = min( R*tableWidth, remainingWidth * M[i]/remainingRequested);
remainingWidth -= O[i];
remainingRequested -= M[i];
}

When you implement this just replace i with sortedM[i] inside the loop, where sortedM contains the indexes of M when it would be sorted, so you do not have to reorder the original arrays M and O in the sorting stage.

@Tomas P
This is elegant, but as you said, it is still iterative. That’s also interesting about having a minimum instead of a maximum. Essentially they’re the same, but thinking about it as a minimum may be more effective.

@uhuu
Both algorithms you’ve mentioned are iterative as soon as you say “repeat this, as long as…”, and I basically implement them already in the post, except for the part about sorting.

@r0b0t
That looks like the start of a clever solution… One question/potential problem: after distributing the excess in the third iteration, if R[i] > R, the excess in that case only get distributed to the remaining i+1 to N columns. Is this desired? What if there was an i-x column earlier that was far below R? …or maybe this nuance is actually the essence of the solution?

do
Z=1-(R[1]+…+R[n])
for i=1..n do {if mem[i]==1 then R[i]=R[i]+M[i]/(M[1]*mem[1]+..+M[n]*mem[n])*Z;
if R[i]>R then R[i]=R; mem[i]=0}
until Z ==0

This task has it’s complexity bounded below by O(n^2) because calculating the value of R[i] has impact on all the so far uncomputed values R[j].

Then apply the restriction while remembering on which columns:
for i=1..n do {if R < R[i] then R[i]=R; mem[i]=0}

Finally distribute the remaining ratio Z=1-(R[1]+…+R[n]) via
for i=1..n do {if mem[i]==1 then R[i]=R[i]+M[i]/(M[1]*mem[1]+..+M[n]*mem[n])*Z}

Maybe this can be done without iteration by I think the result would be rather obfuscated. Take for example the Cramer’s rule – in it’s general form for NxN matrices it requires the determinant function.

For worst case speed of O(n^2) you calculate all widths without the additional R constraint. Then do a loop over all widths and cut all values exceeding the maximum R and calculate the sum of the cut widths. And distribute that sum of excess widths proportionally over all columns that are not equal to maximum R (or not greater than R, but of course none of them can be above R in this case). And repeat this, as long as no excess was cut. In the worst case you do that loop n times. Not more than n times, since every time either your loop stops (no excess was cut) or at least one of the widths that was not R becomes R and will stay R till the end of the iteration.

For O(n log n) you need to sort the widths according to their size. This takes O(n log n), after that the remaining part requires just O( n ). So after sorting you start from the largest width. You calculate whether it exceeds the limit R and cut it if necessary and set that to be its optimal value O (and that is also the final optimal value for that column). After that you go to a subproblem of finding the widths of the remaining n-1 columns by reducing the remaining table width by the optimal width value you found for the largest column.

Sorry I was lazy not to write some (pseudo)code… if these explanations were too ambiguous let me know, I put down some code , given that I understood your problem correctly.

//Calculate the widths of all non-maxed-out columns
for{i=1;i<=n;i++)
if (A[i] != M[i])
{A[i]=round(CH[i]*W/T), W-=A[i], T-=CH[i];}

For the kind of solution you want, the `iteration’ probably cannot be avoided (al least without the use of some complex data structures) , but something along the lines of the following (pseudo)code seems simpler and more general: all used variables are integers, the only (brief) use of floats is in the last for{} loop.
Sorry for changing your notation… your M corresponds to my CH, your O to my A. I did not change the indexes, though, so that the arrays run from 1 to n, which may not be ideal…

The same units (say, pixels) are used for A[], M[], W.
Some possibly other units can be used for CH[], T (these are used purely for dealing with proportions).

The following ought to work with a certain maximum set individually for each column. Replacing M[i]‘s with a single maximum M is possible, of course.

INPUT
Constants: n number of columns,
M[1..n] maximum allowed column widths, CH[1..n] column width hints
Variables: W total (remaining) width

OUTPUT
A[1..n] final column widths

LOCAL VARIABLES
Variables: i index in 1..n,
W total remaining width, T total hints of not-maxed-out-yet column

Invariants: W/T nondecreasing in the while{} loop,
number of maxed-out columns increasing

//Initialize … {i=1, T = sum over 1..n of CH[i], A=[0,..,0]}
…
//Find all maxed-out columns, give them the M[i] width
while(i= T*M[i])
{A[i]=M[i], W-=M[i], T-=CH[i]; i=0}
//i=0 means start over, since we found a new maxed-out column
//and hence W/T might have increased
i++;
}
//Calculate the widths of all non-maxed-out columns
for{i=1,i0) … //Fail (cannot fill W when restricted by such small maxima M[])
else … //Return A[1..n]

Use while(++i<=n) if you really really want to make the whole while statement a one-liner (initializing with i=0).

That does not change the fact that the body of while() may execute n^2 times, but this is hardly an issue for the intended application.

The body of the last loop bothers with updating W and T so that the rounding/discretizations errors (which are spread over A[]) average to zero (I hope, the sum of A[] should be the originally input W).

As for the R condition, the problem is that moving along such a line can make you run out of the hypercube in another dimension. I can’t really think of a better solution than either moving back along another line or stopping at the border of the hypercube and taking a new line (which only distributes to the dimensions which are not maxed out yet) from there (which sounds like a better / more elegant solution, but is harder to code and should give the same result in the same number of iterations, so it isn’t really that great).

Still following? I cannot guarantee correctness, for that I would need a piece of paper and a pen, but my above reasoning would lead me to think that geometrically it can be done by solving some systems to find the intersection points. So just a library to solve linear system of equation would be needed, but those are very fast.

@VPeric
When determining the ratio, precession does matter to a somewhat significant degree because we multiply ratios with an arbitrarily large width to determine pixels.

The problem is that when redistributing the difference between R and the real ratio, you may push the other columns over R, which means another iterative pass must be done to catch this.

@Florian
Thinking of it as a maximization problem… hmm. Thanks for the links.

Maximize z = C1O1+…+CnOn with Ci = Mi/(M1+…+Mn)
Subject to
Oi <= Mi
O1+…+On <= W
-O1-…-On <= W
Oi <= W*R

See http://en.wikipedia.org/wiki/Simplex_algorithm
and http://en.wikipedia.org/wiki/Linear_programming for a starting point.

First of all, since we’re dealing with pixels, it doesn’t really have to be _that_ precise. With that in mind, here’s a simple algorithm that needs only two passes:

remain=0;
for (i=0; i<n; i++){ //n – number of columns
t=suggestedwidth[i]/W;
if (t<R){
remain += R-t;
} else {
//optionally, remember the index i
suggestedwidth[i]=R;
}
}
remain = remain*W //convert ratio to pixels
//distribute pixels among all columns equally, or just to those who were too short, if you remembered the index above

Yes, I’m sure you could’ve thought of that yourself, but the point is that something like that is a suitable amount of approximation. And, even if it isn’t particulary fast, coding it like this would make it _immensly_ easier to add an additional column or three.

Hope that helps; I’ll stop by if I think of an actual mathematical solution!

You seem to define three (types of constraints ) (here written for your example of three due to the limits of the medium)
O1+O2+O3=W
O1<=WR
O2<=WR
O3<=WR
O1<=M1
O2<=M2
O3<=M3

Am I right?