persistable sclass InterpolatedDoubleArray is IntSize {

  int[] indices;

  double[] values;

  *(int[] *indices, double[] *values) {}

  public int size aka length() {

    ret empty(indices) ? 0 : last(indices)+1;

  }

  int nPillars() {

    ret l(indices);

  }

  double[] toDoubleArray aka get() {

    int n = length();

    double[] array = new[n];

    for (int i = 0; i < indices.length; i++) {

      int iEnd = indices[i];

      double value = values[i];

      array[iEnd] = value;

      if (i > 0) {

        int iStart = indices[i-1];

        if (iStart+1 < iEnd) {

          double startValue = values[i-1];

          double step = (value-startValue)/(iEnd-iStart), val = startValue;

          for (int j = iStart+1; j < iEnd; j++) {

            val += step;

            array[j] = val;

          }

        }

      }

    }

    ret array;

  }

  int[] rounded() {

    ret iroundDoubleArray(get());

  }

  double[] indicesAndValues() {

    int n = nPillars();

    double[] array = new[n*2];

    for i to n: {

      array[i*2] = indices[i];

      array[i*2+1] = values[i];

    }

    ret array;

  }

  double[] indicesAndValues_withoutFirstAndLastIndex() {

    int n = nPillars();

    double[] array = new[max(1, n*2-2)];

    int j = 0;

    for i to n: {

      if (i != 0 && i != n-1)

        array[j++] = indices[i];

      array[j++] = values[i];

    }

    ret array;

  }

  int nInts_withoutFirstAndLastIndex() {

    ret max(1, nPillars()*2-2);

  }

  int nInts() {

    ret nPillars()*2;

  }

  InterpolatedDoubleArray topPart(int nPillars) {

    ret new InterpolatedDoubleArray(

      takeFirst(nPillars, indices),

      takeFirst(nPillars, values));

  }

}