Added One-Dimensional Ordering Problem

We added the one-dimensional ordering problem.
The goal is to arrange n objects on a 1-dimensional (e.g., horizontal) axis given a distance matrix describing their location in a potentially high-dimensional or unstructured space.
The objects should be arranged in such a way that, for each object,

• the nearest neighbors on the 1-dimensional axis are also the nearest neighbors in the original space (according to the distance matrix provided),
• the second nearest neighbors on the 1-dimensional axis are also the second nearest neighbors in the original space (according to the distance matrix provided),
• the third nearest neighbors on the 1-dimensional axis are also the third nearest neighbors in the original space (according to the distance matrix provided),
• and so on; with (quadratically) decreasing weights of neighbor distance ranks.

The original distances be limited to integers for the sake of simplicity, but we may use floats as well if we want to.
Either way, we do not care about the actual precise distances (e.g., something like "0.001") between the objects on either the one-dimensional nor the original space.
Only about the distance ranks, i.e., about "2nd nearest neighbor," but not "0.012 distance units away."
The solutions of this problem are thus permutations (orders) of the objects.
Of course, if we really want to plot the objects, such a permutation can easily be translated to x-coordinates, say, by dividing the index of an object by the number of objects, which nets values in [0,1].
But basically, we reduce the task to finding permutations of objects that reflect the neighbor structure of the original space as closely as possible.

If such a problem is solved correctly, then the arrangement on the one-dimensional axis should properly reflect the arrangement of the objects in the original space.
Of course, solving this problem exactly may not actually be possible, since an object on a one-dimensional axis may either have exactly two i-nearest-neighbors (if it is at least i slots away from either end of the permutation) or exactly 1 such neighbor, if it is closer that i units.
The object directly at the start of the permutation has only 1 nearest neighbor (the object that comes next).
That next object, however, has two, namely the first object and the third object.
In the original space where the objects come from, however, there may be any number of "nearest neighbors."
Imagine a two-dimensional space where one object sits at the center of a circle of other objects.
Then all other objects are its nearest neighbors, whereas an object on the circle either has exactly two nearest neighbors or, maybe, in the odd situation that the radius equals a multiple of the distance to the neighbors on the circle, three.
Such a structure cannot be represented exactly in one dimension.

But that's OK.
Because we mainly do this for visualization purposes anyway.

improved dynamic control surrogate modelling and output

improved dynamic control surrogate modelling and output

Further Improvement for ODE Tools

Further Improvement for ODE Tools

The number of points is now fixed.
We only use interpolation points at fixed intervals.

more attempts to stabilize objective and speed up tests

more attempts to stabilize objective and speed up tests

some small improvements to the new ODE integration method

some small improvements to the new ODE integration method

New ODE Integration Approach

My old, own ODE integration approach fails for three
oscillators model. It probably does so because it has too many
dimensions.
After some deliberation, I decided to kick it out.
Instead, we now use the scipy integration.
However, we need to deal with situations where the system
diverges, where either control or state go to infinity.
We can do this because we use the iterative integration
method. Once an integration step fails, we discard the
previous data and start again, but set the time limit to
something between the largest successful and smallest failing
time.
This way, we should be able to step-by-step approximate the
time limit until which an ill-behaved system remains in an
acceptable state.

The side-effects of the new method are:

1. It may be slower.
2. The number of samples changes dynamically and is no longer
   fixed.
3. If we approximate the differential from the data, then the
   values we find in the integration result are actually not
   real differential values.
   They are differences for different interpolation steps of
   the function.

Version Stepping of Dependencies, Improved TTP Documentation, and more Bin Packing Objectives

• the dependencies are updated
• the Traveling Tournament Problem is better documented
• several new objectives have been added to the two-dimensional bin packing problem

minor improvements for the TTP

minor improvements for the TTP

minor fix to to-string routine for game plans

0.8.23

minor fix to to-string routine for game plans

First Steps into the Traveling Tournament Problem (TTP)

First Steps into the Traveling Tournament Problem (TTP)