Refactoring random strategy

Author: mccaffers

include/models/trade.hpp

@@ -26,8 +26,8 @@ struct Trade {
     std::string dealReference;
     std::string symbol;
     int scalingFactor;
-    double stopDistancePips;
-    double limitDistancePips;
+    boost::decimal::decimal64_t stopDistancePips;
+    boost::decimal::decimal64_t limitDistancePips;
     std::string strategyId;
     std::string strategyName;
 

include/strategies/randomStrategy.hpp

@@ -16,9 +16,11 @@
 class TradeManager;  // forward declared in strategy.hpp; redeclaring is harmless
 
 // A trivial strategy: on every tick it flips a fair coin and returns
-// LONG or SHORT. While trades are open it has a small per-tick chance
-// of closing every active position. Intended as scaffolding for the
-// strategy interface, not as a real trading approach.
+// LONG or SHORT. Exits are not the strategy's responsibility — they
+// are driven by the stop-loss / take-profit pip distances configured
+// on the trade and enforced centrally by Operations. Intended as
+// scaffolding for the strategy interface, not as a real trading
+// approach.
 //
 // C# parallels for readers from a C# background:
 //   - `class` here is a value/owning type managed via stack or
@@ -49,11 +51,12 @@ class RandomStrategy : public IStrategy {
     // interface stable for strategies that will look at price.
     std::optional<Direction> decide(const PriceData& tick) override;
 
-    // Per-tick management hook. With a small probability per tick
-    // (see `closeProb`), closes every currently-open trade at the
-    // tick's bid price. `tradeManager` is passed by mutable reference
-    // because the strategy needs to call mutating methods on it
-    // (`closeTrade`); `getActiveTrades()` is still safely const.
+    // Per-tick management hook. The default RandomStrategy
+    // implementation is a no-op — Operations closes trades when
+    // their stop-loss or take-profit boundary is hit. `tradeManager`
+    // is passed by mutable reference so future strategies (trailing
+    // stops, partial closes, scale-ins) can act on open positions
+    // here without changing the interface.
     void during(std::size_t tickValue,
                 const PriceData& price,
                 TradeManager& tradeManager) override;

include/trading/tradeManager.hpp

@@ -19,7 +19,11 @@ class TradeManager {
 
 public:
     TradeManager() = default;
-    std::string openTrade(const PriceData& tick, boost::decimal::decimal64_t size, Direction direction);
+    std::string openTrade(const PriceData& tick,
+                          boost::decimal::decimal64_t size,
+                          Direction direction,
+                          boost::decimal::decimal64_t stopDistancePips = boost::decimal::decimal64_t{0},
+                          boost::decimal::decimal64_t limitDistancePips = boost::decimal::decimal64_t{0});
     size_t reviewAccount() const;
     bool closeTrade(const std::string& tradeId, boost::decimal::decimal64_t closePrice);
     const std::unordered_map<std::string, Trade>& getActiveTrades() const;

source/operations.cpp

@@ -9,62 +9,113 @@
 #include <iostream>
 #include <vector>
 #include <memory>
+#include <optional>
 #include <string>
+#include <utility>
 #include <iomanip>
 #include <cstdio>
 #include <ctime>
 #include <boost/decimal.hpp>
 #include "tradeManager.hpp"
+#include "models/symbolScale.hpp"
 #include "strategies/randomStrategy.hpp"
 
+namespace {
+
+// Decide whether the current tick has hit a trade's stop-loss or
+// take-profit boundary. Returns the price at which the position would
+// close (bid for LONG exits, ask for SHORT exits) along with a flag
+// — `std::nullopt` means "no exit on this tick".
+//
+// Pip → price conversion uses the symbol's scaling factor: a 1.5-pip
+// distance on EURUSD (scale 10000) is 0.00015; on USDJPY (scale 100)
+// it's 0.015. Trades on unknown symbols (scale 0) are skipped — there
+// is no sensible pip distance to apply.
+std::optional<boost::decimal::decimal64_t>
+checkExit(const Trade& trade, const PriceData& tick) {
+    if (trade.scalingFactor == 0) return std::nullopt;
+    if (trade.stopDistancePips == 0 &&
+        trade.limitDistancePips == 0) {
+        return std::nullopt;
+    }
+
+    const auto stopOffset  = trade.stopDistancePips  / trade.scalingFactor;
+    const auto limitOffset = trade.limitDistancePips / trade.scalingFactor;
+
+    if (trade.direction == Direction::LONG) {
+        const auto stopPrice  = trade.entryPrice - stopOffset;
+        const auto limitPrice = trade.entryPrice + limitOffset;
+        // Exit a long at the bid (the price the broker pays us).
+        if (trade.stopDistancePips  != 0 && tick.bid <= stopPrice)  return tick.bid;
+        if (trade.limitDistancePips != 0 && tick.bid >= limitPrice) return tick.bid;
+    } else {
+        const auto stopPrice  = trade.entryPrice + stopOffset;
+        const auto limitPrice = trade.entryPrice - limitOffset;
+        // Exit a short at the ask (the price we pay to buy back).
+        if (trade.stopDistancePips  != 0 && tick.ask >= stopPrice)  return tick.ask;
+        if (trade.limitDistancePips != 0 && tick.ask <= limitPrice) return tick.ask;
+    }
+    return std::nullopt;
+}
+
+// Walk every active trade, close any whose SL/TP has been hit on this
+// tick. Two-phase to avoid invalidating the map iterator while erasing.
+void reviewStopAndLimit(TradeManager& tradeManager, const PriceData& tick) {
+    const auto& openTrades = tradeManager.getActiveTrades();
+    if (openTrades.empty()) return;
+
+    std::vector<std::pair<std::string, boost::decimal::decimal64_t>> toClose;
+    toClose.reserve(openTrades.size());
+    for (const auto& [id, trade] : openTrades) {
+        if (auto exitPrice = checkExit(trade, tick)) {
+            toClose.emplace_back(id, *exitPrice);
+        }
+    }
+    for (const auto& [id, exitPrice] : toClose) {
+        tradeManager.closeTrade(id, exitPrice);
+    }
+}
+
+} // namespace
+
 void Operations::run(const std::vector<PriceData>& ticks,
                      const trading_definitions::Configuration& config) {
 
-    // Create
-    auto tradeManager = new TradeManager();
+    auto tradeManager = std::make_unique<TradeManager>();
     RandomStrategy strategy(config.STRATEGY);
 
+    const auto& tradingVars = config.STRATEGY.TRADING_VARIABLES;
+
     std::size_t tickIndex = 0;
     for (const auto& tick : ticks) {
 
+        // Close any trade whose stop-loss or take-profit fired on this tick
+        // before we consider opening a new one — otherwise an exit and an
+        // entry could race within the same tick.
+        reviewStopAndLimit(*tradeManager, tick);
+
         size_t openTrades = tradeManager->reviewAccount();
 
         // only open a trade if there is zero
         if (openTrades == 0) {
             // optional is false
             if (auto signal = strategy.decide(tick)) {
-                std::string tradeId = tradeManager->openTrade(tick, config.STRATEGY.TRADING_VARIABLES.TRADING_SIZE, *signal);
-                std::cout << "Opened trade: " << tradeId << std::endl;
+                tradeManager->openTrade(tick,
+                                        tradingVars.TRADING_SIZE,
+                                        *signal,
+                                        tradingVars.STOP_DISTANCE_IN_PIPS,
+                                        tradingVars.LIMIT_DISTANCE_IN_PIPS);
             }
         }
 
-        // this would be a position manager review point
-        // randomly check account status every 100 ticks
-        if (openTrades > 0 && (std::rand() % 100) == 0) { // NOSONAR(cpp:S2245) experimentation only, not security-sensitive
-            std::cout << "Reviewing account at tick timestamp: " << tick.timestamp.time_since_epoch().count() << std::endl;
-            std::cout << "Number of open trades: " << openTrades << std::endl;
-            for (const auto& [id, trade] : tradeManager->getActiveTrades()) {
-                std::cout << "Trade ID: " << id
-                        << " | Entry: " << trade.entryPrice
-                        << " | Size: " << trade.size
-                        << " | Direction: " << (trade.direction == Direction::LONG ? "LONG" : "SHORT")
-                        << std::endl;
-            }
-        }
-
-        // Strategy-driven management hook. The strategy itself decides
-        // whether/when to close positions; the random strategy currently
-        // closes every open trade with a small per-tick probability.
-        // Dereferencing `tradeManager` (a raw pointer) yields a reference
-        // — the parameter type is `TradeManager&`, so `*tradeManager`
-        // is what we hand in.
+        // Strategy-driven management hook for non-SL/TP exit logic
+        // (e.g. trailing stops, partial closes). The default
+        // RandomStrategy implementation is a no-op now that exits are
+        // handled by reviewStopAndLimit above.
         strategy.during(tickIndex, tick, *tradeManager);
 
         ++tickIndex;
     }
 
     std::cout << "Final PnL: " << std::fixed << std::setprecision(2) << tradeManager->calculatePnl() << std::endl;
-
-    // bool closed = tradeManager->closeTrade(tradeId);
-    // std::cout << "Trade closed: " << (closed ? "yes" : "no") << std::endl;
 }

source/strategies/randomStrategy.cpp

@@ -6,10 +6,6 @@
 
 #include "strategies/randomStrategy.hpp"
 
-#include <iostream>
-#include <string>
-#include <vector>
-
 #include "tradeManager.hpp"
 
 // Member initialiser list (the bit after the `:`) runs in declaration
@@ -21,31 +17,17 @@ RandomStrategy::RandomStrategy(const trading_definitions::Strategy& strategyConf
     : config(strategyConfig),
       rng(std::random_device{}()),       // seed once from the OS entropy source
       coin(0.5),
-      closeProb(1.0 / 200.0) {}          // ~0.5% chance per tick — same odds as the
-                                         // old `std::rand() % 200 == 0` in operations.cpp
+      closeProb(0.0) {}                  // unused — exits are driven by SL/TP in Operations
 
 std::optional<Direction> RandomStrategy::decide(const PriceData& /*tick*/) {
     return coin(rng) ? Direction::LONG : Direction::SHORT;
 }
 
 void RandomStrategy::during(std::size_t /*tickValue*/,
-                            const PriceData& price,
-                            TradeManager& tradeManager) {
-    const auto& openTrades = tradeManager.getActiveTrades();
-    if (openTrades.empty()) return;
-    if (!closeProb(rng)) return;
-
-    // Two-phase pattern: collect IDs first, then close. Closing inside
-    // the range-for loop would invalidate the iterator we're walking,
-    // because `closeTrade` erases the entry from the underlying map.
-    // Same trap as mutating a C# Dictionary while iterating it.
-    std::vector<std::string> idsToClose;
-    idsToClose.reserve(openTrades.size());
-    for (const auto& [id, trade] : openTrades) {
-        idsToClose.push_back(id);
-    }
-    for (const auto& id : idsToClose) {
-        bool closed = tradeManager.closeTrade(id, price.bid);
-        std::cout << "Closed trade ID: " << id << " - " << (closed ? "success" : "failure") << std::endl;
-    }
+                            const PriceData& /*price*/,
+                            TradeManager& /*tradeManager*/) {
+    // Exits are handled centrally by Operations using each trade's
+    // stop-loss / take-profit pip distances. Strategies that want
+    // bespoke exit logic (trailing stops, partial closes, etc.)
+    // should override this hook.
 }

source/trading/tradeManager.cpp

@@ -14,10 +14,16 @@ std::string nextTradeId() {
 }
 }
 
-std::string TradeManager::openTrade(const PriceData& tick, boost::decimal::decimal64_t size, Direction direction) {
+std::string TradeManager::openTrade(const PriceData& tick,
+                                    boost::decimal::decimal64_t size,
+                                    Direction direction,
+                                    boost::decimal::decimal64_t stopDistancePips,
+                                    boost::decimal::decimal64_t limitDistancePips) {
     auto price = (direction == Direction::LONG) ? tick.ask : tick.bid;
     Trade trade(price, size, direction, tick.symbol);
     trade.id = nextTradeId();
+    trade.stopDistancePips = stopDistancePips;
+    trade.limitDistancePips = limitDistancePips;
     activeTrades[trade.id] = trade;
     return trade.id;
 }