persistable sclass PullbackToProfitAnalysisBase {

  settable double pullbackLimit = 1.0;

  settable double adversity = 0.2;

  settable boolean isShort;

  settable TickerSequence ticker;

  settable long startTime;

  settable L<PullbackToProfit> ptpList;

  settable double openingPrice;

  double priceToProfit(double price) {

    var profit = asPercentIncrease(price, openingPrice());

    if (isShort()) profit = neg(profit);

    ret profit-adversity();

  }

  run {

    if (notNull(ptpList())) ret;

    if (startTime == 0) startTime = ticker().startTime();

    var idx1 = ticker().indexOfTimestamp(startTime());

    openingPrice(ticker().getPrice(idx1));

    var crest = 0.0; //negativeInfinity

    var maxPullback = 0.0;

    ptpList = new L;

    int n = ticker().size();

    for (int idx = idx1; idx < n; idx++)  {

      var price = ticker().getPrice(idx);

      var time = ticker().getTimestamp(idx);

      var profit = priceToProfit(price);

      crest = max(crest, profit);

      var pullback = crest-profit;

      maxPullback = max(maxPullback, pullback);

      if (maxPullback >= pullbackLimit()) {

        printConcat("Ending at pullback ", maxPullback, " (", formatMinutes(time-startTime()), ")");

        break;

      }

      var result = new PullbackToProfit().pullback(maxPullback).profit(crest-maxPullback);

      var prev = last(ptpList());

      if (prev != null)

        if (prev.replaces(result))

          continue;

        else if (result.replaces(prev))

          popLast(ptpList);

      ptpList.add(result

        .isShort(isShort)

        .timestamp(time)

        .startTime(startTime()));

    }

  }

  double maxCleanness() {

    run();

    ret doubleMax(map(ptpList(), ptp -> ptp.cleanness());

  }

  PullbackToProfit cleanestPTP() {

    run();

    ret highestBy(ptpList(), ptp -> ptp.cleanness());

  }

}