*
* Invoke as ./main n m
*
- * The algorithm is faster if the arguments are ordered so that n > m.
+ * The arguments must be ordered so that n > m:
+ * n is the number of (more, shorter) input matches of length m
+ * m is the number of (fewer, longer) output matches of length n
*/
/*
*
* We further winnow the set of possible adjacency matrices, by
* ensuring the same bit is not set in too many entries of adjmatrix
- * (ie, as above, only considering output sticks).
+ * (ie, as above, only considering output sticks); and by ensuring
+ * that it is not set in too few: each output stick must consist
+ * of at least two fragments since the output sticks are longer than
+ * the input ones.
*
* And, we want to do the search in order of increasing maximum
* hamming weight. This is because in practice optimal solutions tend
* <=> frags < | n / best |
* _ _
* <=> frags <= | n / best | - 1
+ *
+ * But best values from glpk are slightly approximate, so we
+ * subtract a fudge factor from our target.
*/
- n_max_frags = ceil(n / best) - 1;
- m_max_frags = ceil(m / best) - 1;
+ double near_best = best * 0.98 - 0.02;
+ n_max_frags = ceil(n / near_best) - 1;
+ m_max_frags = ceil(m / near_best) - 1;
}
/*----- multicore support -----*/
AdjWord jbit;
if (i >= n) {
+ for (j=0; j<m; j++)
+ if (weight[j] < 2)
+ return;
+
printcounter++;
optimise(!(printcounter & 0xfff));
return;
assert(argc==3);
n = atoi(argv[1]);
m = atoi(argv[2]);
+ assert(n > m);
prep();