replace real with double.

replace Real with Double.

srecord noeq MPM2(real[] ticker) {

  // how much percentual slippage we have for each position on

  // average dependent on the market (trading site) we are using

  srecord Market(real adversity) {}

  srecord Juicer(real lossTolerance, real pullback) {}

  srecord Position(real openingTime, real direction) {}

  srecord noeq LiveTicker(real[] data, int time) {

    Real currently() { ret lookback(0); }

    Real lookback(real time) {

      int index = iceil(this.time-1-time);

      ret index >= 0 ? data[index] : null;

    }

    void add(real value) {

      if (time >= l(data)) {

        data = resizeArray(data, max(1, limitToSafeArraySize(l(data)*2L)));

        if (time >= l(data)) fail("Can't handle more than 2 billion ticker entries");

      }

      data[time++] = value;

    }

  }

  srecord Eye(real time, real minMove) {

    real adviseDirection(LiveTicker ticker) {

      Real currently = ticker.currently();

      if (currently == null) ret 0;

      Real before = ticker.lookback(time);

      if (before == null) ret 0;

      real move = currently-before;

      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)) break;

      ++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));

  }

  abstract class Convergent extends ItIt<Real> {

    Real value;

    bool stepped, done;

    public bool hasNext() {

      if (done) false;

      if (!stepped) {

        stepped = true;

        step();

      }

      ret !done;

    }

    public Real next() {

      assertTrue(hasNext());

      stepped = false;

      ret value;

    }

    abstract void step();

  }

  // eye can be null, then we just test the juicer

  record noeq Backtest(Eye eye, Juicer j, Market m) extends Convergent {

    Iterator<Int> openingTimes = new WeightlessShuffledIterator<Int>(intRangeList(ticker.length));

    new Average profitPerPosition;

    new Average positionsOpenedPercentage;

    // percentage of positions closed before reaching the end of the ticker "tape"

    new Average positionsClosedInTimePercentage;

    void step {

      if (!openingTimes.hasNext())

        ret with done = true;

      int openingTime = openingTimes.next();

      Real profit;

      if (eye == null)

        profit = profitability(openingTime, j, m);

      else {

        real direction = eye.adviseDirection(new LiveTicker(ticker, openingTime));

        positionsOpenedPercentage.addSample(direction != 0 ? 100 : 0);

        if (direction == 0)

          ret;

        Position position = new Position(openingTime, direction);

        profit = profit(position, j, m);

      }

      positionsClosedInTimePercentage.addSample(profit != null ? 100 : 0);

      if (profit != null)

        profitPerPosition.addSample(profit);

      value = profitPerPosition!;

    }

  }

}