• the fast but not-quite-right solution I started with
• the quadratic programming solution discussed in the comments
• and a new linear-time algorithm

I think the new algorithm produces the same optimal solution defined by the quadratic programming algorithm, but my current proof of it is so ugly that it’s too much work to set it out here and I don’t trust it. I think I’m on the tail of a more elegant proof now - I’ll make a new blog entry if I find it. In any case, this algorithm is much faster than the CVXOPT-based solution and produces results that look indistinguishable, without the artifacts of the first algorithm.

Fast algorithm:

    def place_labels(xmin, xmax, lwidth, xpos):
        offsets = [x - i * lwidth for i, x in enumerate(xpos)]
        max_offset = xmax - lwidth * (len(xpos) -1)
        return [i * lwidth + max(xmin, min(max_offset,
            (max(offsets[:i+1]) + min(offsets[i:])) / 2.0))
            for i in range(len(xpos))]

CVXOPT-based algorithm:

    import sys
    sys.path.append('/home/paul/path/lib/python')

    import cvxopt.base
    import cvxopt.solvers
    cvxopt.solvers.options['show_progress'] = False
    cvxopt.solvers.options['maxiters'] = 5000
    #cvxopt.solvers.options['feastol'] = 1E-15

    def place_labels(xmin, xmax, lwidth, xpos):
        n = len(xpos)
        res = cvxopt.solvers.qp(
            cvxopt.base.spmatrix(1.0, range(n), range(n)),
            -cvxopt.base.matrix(xpos),
            cvxopt.base.spmatrix(-1, range(n), range(n), (n+1, n))
                + cvxopt.base.spmatrix(1, range(1, n+1), range(n), (n+1, n)),
            cvxopt.base.matrix([0.0 - xmin] + [-lwidth for i in range(len(xpos)-1)] + [xmax]))
        if res['status'] != 'optimal':
            raise Exception("Label optimizer failed: " + repr(res))
        return [x for x in res['x']]

New fast and perhaps optimal algorithm:

    class PointGroup(object):
        def __init__(self, kind, n, x):
            self.kind = kind
            self.n = n
            self.x = x

    def place_labels(xmin, xmax, lwidth, xpos):
        groups = [PointGroup('l', 0, xmin)] + [PointGroup('m', 1, x) for x in xpos] + [PointGroup('r', 0, xmax + lwidth)]
        res = []
        for g in groups:
            res.append(g)
            while len(res) >= 2 and res[-2].x + lwidth * res[-2].n >= res[-1].x:
                left = res[-2]; right = res[-1]
                del res[-2:]
                if left.kind == 'l' and right.kind == 'm':
                    res.append(PointGroup('l', left.n +right.n, left.x))
                elif left.kind == 'm' and right.kind == 'r':
                    res.append(PointGroup('r', left.n + right.n, right.x - lwidth * left.n))
                elif left.kind == 'm' and right.kind == 'm':
                    res.append(PointGroup('m', left.n + right.n,
                        (left.x * left.n + (right.x - left.n * lwidth) * right.n) / float(left.n + right.n)))
                else:
                    raise Exception("Bonk!")
        return [g.x + lwidth * i for g in res for i in range(g.n)]

(I + G’diag(d)G)dx = r

where ‘d’ is a given positive scaling vector. That’s a
tridiagonal system, that can be solved very efficiently;
the next release of CVXOPT will include the banded
solvers in LAPACK suited for something like this.

Joachim

Specifying this problem as sparse will be much faster for
anything but toy-problems:


P = spmatrix(1.0, range(n), range(n))
q = matrix(xpos)
G = spmatrix(-1,range(n),range(n),(n+1,n)) + \
spmatrix( 1,range(1,n+1),range(n),(n+1,n))
h = matrix([0.0 - xmin] + [-lwidth for i in range(len(q)-1)] + [xmax]);
res = solvers.qp(P, q, G, h)


Best
Joachim

d = 0.1
a = arange(n) + uniform(-d, d, n)

x = variable(n, ‘x’)
cxlow = ( xmin <= x )
cxup = ( x <= xmax )
c_d = [ x[i+1] - x[i] >= d for i in range(n-1) ]

t = variable(n, ‘t’)
ctlow = ( -t <= a - x )
ctup = ( a - x <= t )
lp1 = op(t, [ cxlow, cxup ] + cd + [ ctlow, ct_up ])

tinf = variable(1, ‘tinf’)
ctinflow = ( -tinf <= a - x )
ctinfup = ( a - x <= tinf )
lpinf = op(t, [ cxlow, cxup ] + cd + [ ctinflow, ctinf_up ])

lp_1.solve()
print x.value(), t.value()

l1 norm
min \sumi ti
s.t.
xmin <= xi <= xmax
x{i+1} - xi >= d
-ti <= ai - xi <= ti

l\infty norm
min t
s.t.
xmin <= xi <= xmax
x{i+1} - xi >= d
-t <= ai - xi <= t

The l_2 norm would give a quadratic programming problem.

You can solve linear programming (and other) problems in python using for example cvxopt (http://www.ee.ucla.edu/~vandenbe/cvxopt/).