!include #1000522 // image helper functions

static abstract class Predictor {

  // col = immutable array!

  abstract float[] nextColumn(float[] col);

}

sclass Best {

  S desc;

  double score;

  Predictor renderer;

  *() {}

  *(S *desc, double *score, Predictor *renderer) {}

  int l() { ret main.l(desc); }

}

sclass Reproducing {

  BWImage bw; // original

  float[][] bwCols; // in columns

  bool testFirst; // test first column?

  new LinkedBlockingQueue<S> newProducts;

  int maxQueueLength = 10;

  volatile Best shortest100, best;

  int pivotLength = -1; // no length punishment at start

  int pivotStep = 1;

  O startProduction; // optional runnable that starts production

  void push(S product) {

    if (product == null) ret;

    while (newProducts.size() >= maxQueueLength && mayRun())

      sleep(100);

    newProducts.add(product);

  }

  bool solved() {

    ret getScore(best) >= 100.0;

  }

  S bestDesc() {

    ret getDesc(best);

  }

  void produce() {

    callF(startProduction);

  }

  void search() {

    produce();

    long lastPrint = 0, lastN = 0;

    for (long ntry = 1; ; ntry++) {

      ping();

      long now = now();

      if (now >= lastPrint+1000) {

        long tps = (ntry-lastN)*1000/(now-lastPrint);

        lastPrint = now;

        lastN = ntry;

        String s = "Try " + ntry + " (" + tps + "/s)";

        /*if (best == null)

          print(s);

        else {

          print("Best: " + best.desc);

          print(s + ", score: " + formatDouble(best.score, 2) + "%, l=" + l(best.desc) + ", pivotL=" + pivotLength + "/" + fullGrabLength + (shortest100 == null ? "" : ", shortest100=" + shortest100.l()));

        }*/

      }

      S desc = grabFromQueue(newProducts);

      Predictor p;

      try {

        p = makePredictor(desc);

      } catch {

        print("Can't unstructure: " + desc);

        continue;

      }

      print("Predictor: " + desc);

      double score = testPredictor(p);

      print("  Score: " + score);

    }

  }

  Predictor nextPredictor() {

    S desc = grabFromQueue(newProducts);

    try {

      ret makePredictor(desc);

    } catch {

      print("Can't unstructure: " + desc);

      null;

    }

  }

  double testPredictor(Predictor p) {

    ret main.testPredictor(p, getCols(), testFirst);

  }

  float[][] getCols() {

    if (bwCols == null) bwCols = imageToColumns(bw);

    ret bwCols;

  }

}

static Predictor makePredictor(S desc) {

  ret (Predictor) unstructure(desc);

}

static double getScore(Best b) {

  ret b == null ? 0 : b.score;

}

static S getDesc(Best b) {

  ret b == null ? null : b.desc;

}

static float[][] imageToColumns(BWImage img) {

  int w = img.getWidth(), h = img.getHeight();

  float[][] f = new float[w][h];

  for x to w: for y to h: f[x][y] = img.getPixel(x, y);

  ret f;

}

static BWImage columnsToImage(float[][] cols) {

  ret columnsToImage(cols, l(cols[0]));

}

static BWImage columnsToImage(float[][] cols, int h) {

  float emptyBrightness = 0.5f;

  int w = l(cols);

  BWImage img = new BWImage(w, h, emptyBrightness);

  for x to w: if (cols[x] != null) for y to h:

    img.setPixel(x, y, cols[x][y]);

  ret img;

}

static float[] copyColumn(float[] f) {

  ret copyFloatArray(f);

}

static double testPredictor(Predictor p, float[][] bwCols, bool testFirst) {

  int w = l(bwCols), h = l(bwCols[0]);

  double error = 0;

  for (int x = testFirst ? 0 : 1; x < w; x++) {

    float[] f = p.nextColumn(x == 0 ? null : bwCols[x-1]);

    error += colDiff(f, bwCols[x]);

  }

  ret 1-error/((testFirst ? w : w-1)*h);

}

// x0 = from where we start feeding

// x1 = where we start testing

static double testColumnRange(Predictor p, float[][] bwCols, int x0, int x1, int x2) {

  int h = l(bwCols[0]);

  double error = 0;

  for (int x = x0; x < x2; x++) {

    float[] f = p.nextColumn(x == 0 ? null : bwCols[x-1]);

    if (x >= x1)

      error += colDiff(f, bwCols[x]);

  }

  ret 1-error/((x2-x1)*h);

}

static double colDiff(float[] a, float[] b) {

  if (a == null) ret l(b);

  if (b == null) ret l(a);

  int n = l(a);

  double d = 0;

  for (int i = 0; i < n; i++)

    d += Math.abs(a[i]-b[i]);

  ret d;

}

static BufferedImage renderPrediction(S desc, float[][] bwCols) {

  Predictor p = makePredictor(desc);

  int w = l(bwCols), h = l(bwCols[0]);

  float[][] cols = new float[w][];

  for (int x = 0; x < w; x++) {

    float[] f = p.nextColumn(x == 0 ? null : bwCols[x-1]);

    cols[x] = f;

  }

  ret columnsToImage(cols, h).getBufferedImage();

}