sclass Test_CompressToInterpolatedDoubleArray {

  settable int maxPillars = 3;

  settable int minX =-10, maxX = 10;

  settable int maxRunlength = 10;

  settable int nTests = 1_000;

  // result

  new AverageAndMinMax pixelErrors;

  int pixelErrors() { ret iround(pixelErrors.sum()); }

  run {

    simpleTests();

    repeat nTests { multiSlopeTest(); }

    printResults();

  }

  void simpleTests {

    for (double slope = -1; slope <= 1; slope += 1/8.0)

      singleSlopeTest(slope);

    printResults();

  }

  void printResults {

    print();

    printVars(+pixelErrors);

    if (pixelErrors.average() == 0)

      print("PERFECT!");

    else if (pixelErrors.average() <= 1)

      print("A bit less than optimal, but only by 1 pixel");

    else

      print("This is not good.");

  }

  void singleSlopeTest(double slope) {

    int n = 16;

    var data = intArrayFromFunction(n, i -> iround(slope*i));

    testCompression(data, 2);

  }

  void testCompression(int[] data, int maxPillarsAllowed) {

    print();

    printStruct(+data);

    var compressed = CompressToInterpolatedDoubleArray(data)!;

    printStruct(+compressed);

    var reconstructed = compressed!;

    var reconstructed2 = iroundDoubleArray(reconstructed);

    printStruct(+reconstructed);

    // Test reconstructed array

    assertEquals(l(data), l(reconstructed2));

    for i over data: {

      int diff = absDiff(data[i], reconstructed2[i]);

      pixelErrors.add(diff);

      if (diff != 0) {

        print("pixel error " + diff + " at " + i + ": " + data[i] + "/" + reconstructed2[i]);

      }

    }

    // Test that we have achieved sufficient compression

    assertLessThanOrEqualTo("pillars", maxPillarsAllowed, compressed.nPillars());

  }

  int randomX() { ret random_incl(minX, maxX); }

  void multiSlopeTest() {

    int nPillars = random_incl(2, maxPillars);

    new IntBuffer values;

    new IntBuffer pillars;

    // first pillar

    pillars.add(0);

    values.add(randomX());

    // remaining pillars

    for (int iPillar = 1; iPillar < nPillars; iPillar++) {

      int value = randomX();

      int runlength = random_incl(1, maxRunlength);

      if (runlength > 1) {

        int lastValue = last(values);

        double slope = (value-lastValue)/(double) runlength;

        double x = lastValue;

        for (int i = 1; i < runlength; i++)

          values.add(iround(x += slope));

      }

      pillars.add(l(values));

      values.add(value);

    }

    print(+pillars);

    int[] data = values.toArrayNonNull();

    testCompression(data, nPillars);

  }

}