set flag Reparse.
replace real with double.
replace Real with Double.
replace price with float.

srecord noeq MPM2(price[] ticker, long[] timestamps) {
  // How much percentual slippage we have for each position on
  // average plus the fees for the position.
  // Obviously dependent on the market (trading site) we are using.
  srecord Market(real adversity) {}
  
  srecord Position(real openingTime, real direction) {}
  
  record ClosedPosition(Position p, real closingTime) {
    settable Ticker ticker;
    settable real profit;
    
    MPM2 mpm() { ret MPM2.this; }
    
    real openingPrice() { ret MPM2.this.ticker(p.openingTime); }
    real closingPrice() { ret MPM2.this.ticker(closingTime); }
  }
  
  srecord Juicer(real lossTolerance, real pullback) {}

  abstract sclass Eye {
    abstract real adviseDirection(Ticker ticker);
  }
  
  // only the first length items in data and timestamps are looked at
  srecord noeq Ticker(price[] data, long[] timestamps, int length, long currentTime) {
    real currentPrice() { ret data[length-1]; }
    
    Real lookback(real time) {
      int index = binarySearch_insertionPoint(wrapLongArrayAsList(timestamps), lceil(currentTime-time));
      ret index >= 0 ? (real) data[index] : null;
    }
  }
  
  sclass LiveTicker extends Ticker {
    void add(price value, long timestamp) {
      data = addToArrayWithDoublingStrategy(data, length, value);
      timestamps = addToArrayWithDoublingStrategy(timestamps, length, timestamp); 
      length++;
    }
  }
  
  Ticker ticker() { ret new Ticker(ticker, timestamps, l(timestamps), last(timestamps)); }

  srecord SimpleEye(real time, real minMove) extends Eye {
    real adviseDirection(Ticker ticker) {
      Real currentPrice = ticker.currentPrice();
      if (currentPrice == null) ret 0;
      Real before = ticker.lookback(time);
      if (before == null) ret 0;
      real move = currentPrice/before*100-100;
      if (abs(move) >= minMove) ret (real) sign(move);
      ret 0;
    }
  }

  real ticker(real time) { ret ticker[iceil(time)]; }

  real openingPrice(Position p) { ret ticker(p.openingTime); }

  // all "profit" functions return a positive or negative percent value
  real profit(Position p, real time, Market m) {
    ret (ticker(time)/openingPrice(p)*100-100)*p.direction - m.adversity;
  }

  Real closingTime(Position p, Juicer j, Market m) {
    int time = iceil(p.openingTime);
    real openingPrice = ticker(time);
    real crest = -infinity();
    while (time < ticker.length-1) {
      real profit = profit(p, time, m);
      crest = max(crest, profit);
      if (profit < (profit < 0 ? -j.lossTolerance : crest-j.pullback))
        ret (real) time;
      ++time;
    }
    null;
  }

  Real profit(Position p, Juicer j, Market m) {
    Real closingTime = closingTime(p, j, m);
    ret closingTime == null ? null : profit(p, closingTime, m);
  }

  // How profitable is it to open a position of any direction
  // at a certain point in time?
  Real profitability(real time, Juicer j, Market m) {
    ret maxAllowingNull(
      profit(new Position(time, -1), j, m), 
      profit(new Position(time,  1), j, m));
  }
  
  // eye can be null, then we just test the juicer
  record noeq Backtest(Eye eye, Juicer j, Market m) extends Convergent<Real> {
    Iterator<Int> openingTimes = new WeightlessShuffledIterator<Int>(intRangeList(ticker.length));
    
    new Average profitPerPosition;
    // TODO new Average averageHoldTime;
    new Average positionsOpenedPercentage;
    
    // percentage of positions closed before reaching the end of the ticker "tape"
    new Average positionsClosedPercentage;
    
    new L<ClosedPosition> closedPositions;
    
    *(Juicer *j, Market *m) {}
    
    // internal, don't call from outside. Use Convergent/Iterator methods
    void step {
      if (!openingTimes.hasNext())
        ret with done = true;
        
      int openingTime = openingTimes.next();
      
      Real profit = null;
      ClosedPosition closedPosition = null;
      
      if (eye == null) // Test only juicer
        profit = profitability(openingTime, j, m);
      else {
        // Test eye + juicer
        real direction = eye.adviseDirection(new Ticker(ticker, timestamps, openingTime, timestamps[openingTime]));
        positionsOpenedPercentage.addSample(direction != 0 ? 100 : 0);
        if (direction != 0) {
          Position position = new Position(openingTime, direction);
          Real closingTime = closingTime(position, j, m);
          if (closingTime != null) {
            profit = profit(position, closingTime, m);
            closedPosition = new ClosedPosition(position, closingTime).ticker(ticker()).profit(profit);
            closedPositions.add(closedPosition);
          }
        }
      }
      
      positionsClosedPercentage.addSample(profit != null ? 100 : 0);
      if (profit != null) {
        profitPerPosition.addSample(profit);
        //averageHoldTime.addSample(TODO);
      } else // Profit for unclosed positions = 0
        profitPerPosition.addSample(0);
      value = profitPerPosition!;
    }
  }
}