set flag Reparse.

replace real with double.

replace Real with Double.

replace price with float.

// Persistence:

// MPM3.BotInAction is persistable which in turn means

// MPM3, Position, Juicer and other classes are also persistable.

// We don't persist Position.ticker for space reasons though.

persistable sclass MPM3 {

  // MARKET (trading platform)

  // 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.

  settable real marketAdversity = 0.12 + 0.08;

  // SELF-IMPOSED LIMITS

  // How long a position can be held at the longest

  // - only for backtesting!

  gettable real maxPositionDuration = minutesToMS(60);

  real minimalMaxDuration() { ret minutesToMS(1); }

  // correct user if they are stupid

  selfType maxPositionDuration(real whatUserWants) {

    maxPositionDuration = max(whatUserWants, minimalMaxDuration());

    this;

  }

  // POSITIONS

  // An open(ed) position  

  persistable record Position(transient TickerSequence ticker, real openingTime, real direction) {

    // Set this to a non-null value if this is a real position on a real market

    settable O irlInfo;

    // Eye that opened this position

    settable Eye eye;

    real openingPrice() { ret ticker.priceAtTimestamp(openingTime); }

    real profitAtTime(real time) {

      ret (ticker.priceAtTimestamp(time)/openingPrice()*100-100)*direction - marketAdversity;

    }

    real openingTime() { ret openingTime; }

    S directionString() { ret direction > 0 ? "long" : direction  < 0 ? "short" : ""; }

    void restoreTicker(TickerSequence ticker) { this.ticker = ticker; }

    TickerPoint openingTickerPoint() { ret new TickerPoint(ticker, lround(openingTime)); }

  }

  macro forwardToPosition {

    TickerSequence ticker() { ret p.ticker; }

    void restoreTicker(TickerSequence ticker) { p.restoreTicker(ticker); }

    real direction() { ret p.direction; }

    S directionString() { ret p.directionString(); }

    real openingTime() { ret p.openingTime; }

    real openingPrice() { ret p.openingPrice(); }

    Eye eye() { ret p.eye(); }

  }

  persistable record LivePosition(Position p) {

    settable Juicer juicer;

    // highest profit this position has reached

    settable real crest = -infinity();

    settable real time;   // time we last updated this position

    settable real profit; // expected profit at that time

    forwardToPosition

    // return true if any change

    bool update(real time) {

      if (time <= this.time) false;

      this.time = time;

      profit = p.profitAtTime(time);

      crest = max(crest, profit);

      true;

    }

    transient simplyCached real maxClosingTime() {

      ret p.ticker.live() ? infinity()

        : min(p.openingTime+maxPositionDuration, p.ticker.endTime());

    }

    bool shouldClose() {

      ret time >= maxClosingTime()

        || profit < (profit < 0 ? -juicer.lossTolerance : crest-juicer.pullback);

    }

    // >= 1 to close

    // otherwise keep open

    real closeSignal() {

      CloseSignal strongestSignal = closeSignalWithDescription();

      ret strongestSignal == null ? 0 : strongestSignal.trigger;

    }

    CloseSignal closeSignalWithDescription() {

      ret highestBy(closeSignals(), signal -> signal.trigger);

    }

    // trigger = 0 to 1

    record noeq CloseSignal(S reason, real trigger) {}

    L<CloseSignal> closeSignals() {

      new L<CloseSignal> signals;

      // How close are we to the max closing time?

      if (maxClosingTime() < infinity())

        signals.add(new CloseSignal("Age", transformToZeroToOne(time, p.openingTime(), maxClosingTime())));

      // How close are we to our loss limit?

      if (profit < 0)

        signals.add(new CloseSignal("Loss", doubleRatio(-profit, juicer.lossTolerance));

      else

        // How close are we to the pullback limit?

        signals.add(new CloseSignal("Profit", transformToZeroToOne(profit,

          crest, crest-juicer.pullback));

      ret signals;

    }

  }

  record ClosedPosition(Position p, real closingTime) {

    real profit = Double.NaN;

    MPM3 mpm() { ret MPM3.this; }

    forwardToPosition

    real closingTime() { ret closingTime; }

    real closingPrice() { ret ticker().priceAtTimestamp(closingTime); }

    real duration() { ret closingTime()-openingTime(); }

    real profit() {

      if (isNaN(profit))

        profit = p.profitAtTime(closingTime);

      ret profit;

    }

  }

  // Wrappers for L<LivePosition> and L<ClosedPosition>

  // (maybe not needed?)

  sclass LivePositions {

    L<LivePosition> positions = syncL();

  }

  sclass ClosedPositions {

    L<ClosedPosition> positions = syncL();

  }

  // BOT (Eye + Juicer)

  persistable srecord Juicer(real lossTolerance, real pullback) {}

  abstract sclass Eye {

    // returns -1 to open short, 1 to open long

    // and anything in between to do nothing

    abstract real adviseDirection(TickerPoint tickerPoint);

  }

  // time = ms to look back

  srecord SimpleEye(long lookbackTime, real minMove) extends Eye {

    // 0 to 1

    settable real relativeVerificationTime/* = 0.33*/;

    // 0 to 1 (roughly)

    settable real verificationThreshold/* = 0.5*/;

    // in ms

    real verificationTime() {

      ret lookbackTime*relativeVerificationTime;

    }

    // in price percent

    real verificationMoveThreshold() {

      ret minMove*relativeVerificationTime*verificationThreshold;

    }

    // in price percent

    real verificationMove(TickerPoint tickerPoint) {

      ret calculateMove(tickerPoint, verificationTime());

    }

    // in price percent, scaled up to lookbackTime

    real relativeVerificationMove(TickerPoint tickerPoint) {

      ret doubleRatio(verificationMove(tickerPoint)*lookbackTime, verificationTime());

    }

    real verificationSignal(TickerPoint tickerPoint) {

      ret doubleRatio(verificationMove(tickerPoint), verificationMoveThreshold());

    }

    bool verificationEnabled() {

      ret relativeVerificationTime != 0;

    }

    real adviseDirection(TickerPoint tickerPoint) {

      real move = calculateMove(tickerPoint);

      if (isNaN(move)) ret 0;

      real relativeMove = doubleRatio(move, minMove);

      int sign = sign(relativeMove);

      real absRelativeMove = abs(relativeMove);

      if (verificationEnabled()) {

        real verification = max(0, sign*verificationSignal(tickerPoint));

        absRelativeMove = min(absRelativeMove, verification);

      }

      // No more clamping - allow trade signals > 100%

      ret sign*absRelativeMove;

    }

    real calculateMove(TickerPoint tickerPoint, real lookbackTime default this.lookbackTime) {

      if (!tickerPoint.canLookback(lround(lookbackTime))) ret Double.NaN;

      real currentPrice = tickerPoint.currentPrice();

      real before = tickerPoint.lookback(lround(lookbackTime));

      ret currentPrice/before*100-100;

    }

  }

  /*persistable srecord TwoEyes extends Eye {

    settable Eye eye1;

    settable Eye eye2;

    *(Eye *eye1, Eye *eye2) {}

    real adviseDirection(TickerPoint tickerPoint) {

    }

  }*/

  srecord TradingBot(Eye eye, Juicer juicer) {

    *(real lookbackMinutes, real minMove, real maxLoss, real pullback) {

      eye = new SimpleEye(minutesToMS(lookbackMinutes), minMove);

      juicer = new Juicer(maxLoss, pullback);

    }

  }

  class BotInAction extends MetaWithChangeListeners {

    settable TradingBot botConfiguration;

    transient TickerSequence ticker;

    // Both open and closed positions may be purely simulated or

    // mirrors of positions actually made IRL (see Position.irlInfo).

    new ListWithChangeListeners<LivePosition> openPositions;

    new ListWithChangeListeners<ClosedPosition> closedPositions;

    LivePosition openPosition(TickerPoint tickerPoint, real direction) {

      var p = new Position(tickerPoint.ticker(), tickerPoint.time(), direction);

      var livePosition = new LivePosition(p).juicer(botConfiguration.juicer);

      livePosition.update(tickerPoint.time());

      openPositions.add(livePosition);

      change();

      ret livePosition;

    }

    void closePosition(LivePosition position) {

      if (openPositions.remove(position)) {

        // TODO: closedPositions.add...

        change();

      }

    }

    void restoreTicker(TickerSequence ticker) {

      if (ticker == this.ticker) ret;

      this.ticker = ticker;

      ticker.onPricePointAdded(time -> updatePositions(time));

      for (p : openPositions) p.restoreTicker(ticker);

      for (p : closedPositions) p.restoreTicker(ticker);

    }

    void updatePositions(real time) {

      bool anyChange;

      for (p : openPositions) anyChange |= p.update(time);

      if (anyChange) change();

    }

  }

  ClosedPosition runJuicer(Position p, Juicer j) {

    TickerSequence ticker = p.ticker;

    long time = lround(p.openingTime);

    double maxClosingTime = min(time+maxPositionDuration, ticker.endTime());

    real crest = -infinity();

    while (time < maxClosingTime) {

      time = ticker.nextTimestamp(time);

      real profit = p.profitAtTime(time);

      crest = max(crest, profit);

      if (profit < (profit < 0 ? -j.lossTolerance : crest-j.pullback))

        break;

    }

    ret new ClosedPosition(p, time);

  }

  record noeq Backtest(TickerSequence ticker, TradingBot bot) extends Convergent {

    new L<ClosedPosition> closedPositions;

    long time;

    double latestAllowedOpeningTime() {

      ret ticker.endTime()-maxPositionDuration;

    }

    void step {

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

      if (time > latestAllowedOpeningTime())

        ret with done = true;

      TickerPoint tickerPoint = new(ticker, time);

      real direction = bot.eye.adviseDirection(tickerPoint);

      if (abs(direction) < 1)

        // No position to open, move to next timestamp

        time = ticker.nextTimestamp(time);

      else {

        // We have a position to open

        var position = new Position(ticker, time, direction)

          .eye(bot.eye);

        // Ask juicer when to close position

        var closedPosition = runJuicer(position, bot.juicer);

        // Add to record of positions made

        closedPositions.add(closedPosition);

        // Move on to next timestamp

        time = ticker.nextTimestamp(closedPosition.closingTime);

      }

    }

  }

}