diff --git a/src/lib/orderman/orders/algo/algo_orders/FileRunner.cpp b/src/lib/orderman/orders/algo/algo_orders/FileRunner.cpp index bb878bf53..bfcd57686 100644 --- a/src/lib/orderman/orders/algo/algo_orders/FileRunner.cpp +++ b/src/lib/orderman/orders/algo/algo_orders/FileRunner.cpp @@ -155,8 +155,10 @@ void FileRunner::run_algo(const api::orderman::MomentumAlgoParamsFile p) { map["Open " "Position On " "Close"] = dynamic_parameter(p.open_position_on_close()); + map["Use Hull Avg?"] = dynamic_parameter(p.use_hull_avg()); map["Renko Ticks"] = dynamic_parameter(p.renko_ticks()); - map["Gan Buffer Size"] = dynamic_parameter(p.gan_buffer_size()); + map["Upper Gan Buffer Size"] = dynamic_parameter(p.upr_gan_buffer_size()); + map["Lower Gan Buffer Size"] = dynamic_parameter(p.lwr_gan_buffer_size()); map["Edge To Capture"] = dynamic_parameter(p.edge_to_capture()); map["Edge To " "lose"] = dynamic_parameter(p.edge_to_lose()); diff --git a/src/lib/orderman/orders/algo/algo_orders/MomentumAlgo.cpp b/src/lib/orderman/orders/algo/algo_orders/MomentumAlgo.cpp index c87082102..8d055d404 100644 --- a/src/lib/orderman/orders/algo/algo_orders/MomentumAlgo.cpp +++ b/src/lib/orderman/orders/algo/algo_orders/MomentumAlgo.cpp @@ -27,6 +27,7 @@ #include #include #include +#include #include #include #include @@ -34,6 +35,7 @@ #include #include #include +#include #include #include #include @@ -409,18 +411,31 @@ struct GanData { // This is the number of brick highs/lows we keep, default = 100 const size_t upr_buffer_sz; const size_t lwr_buffer_sz; + const size_t upr_mma_sz; + const size_t lwr_mma_sz; // We use a circular_buffer to keep the last highs, lows. With a default of // 100, when we add the 100th element the 0th element is popped out boost::circular_buffer highs, lows; + boost::circular_buffer high_mma, low_mma; double high_sum = 0, low_sum = 0; - explicit GanData(size_t upr_buffer_sz, size_t lwr_buffer_sz) + bool use_hma = false; + explicit GanData(size_t upr_buffer_sz, size_t lwr_buffer_sz, bool hma) : upr_buffer_sz(upr_buffer_sz), lwr_buffer_sz(lwr_buffer_sz), - highs(upr_buffer_sz), lows(lwr_buffer_sz) {} + upr_mma_sz(ceil(sqrt(upr_buffer_sz))), + lwr_mma_sz(ceil(sqrt(lwr_buffer_sz))), highs(upr_buffer_sz), + lows(lwr_buffer_sz), high_mma(upr_mma_sz), low_mma(lwr_mma_sz), + use_hma(hma) {} // As new bricks are created, this function is called void on_data(const Brick &brick) { n_updates++; highs.push_back(brick.edges.high); lows.push_back(brick.edges.low); + if (upr_has_data()) { + high_mma.push_back(mma(highs)); + } + if (lwr_has_data()) { + low_mma.push_back(mma(lows)); + } } void on_data_optimized(const Brick &brick) { @@ -436,6 +451,27 @@ struct GanData { high_sum += brick.edges.high; low_sum += brick.edges.low; } + [[nodiscard]] const static double + weighted_moving_average(const boost::circular_buffer &data, + size_t period) { + double result = 0; + size_t weight = 0; + size_t sum = 0; + + for (size_t i = 0; i < data.size(); i++) { + if (i >= (data.size() - period)) + weight++; + sum += weight; + result += weight * data[i]; + } + return result / sum; + } + [[nodiscard]] const static double + mma(const boost::circular_buffer &data) { + return 2 * weighted_moving_average(data, data.size() / 2) - + weighted_moving_average(data, data.size()); + } + // for early entry exit [[nodiscard]] std::optional high_average_hyp(std::optional temp) const { @@ -455,21 +491,30 @@ struct GanData { l_sum = l_sum + temp.value().low - lows.front(); return l_sum / (double)lows.size(); } + [[nodiscard]] const static double + simple_Avg(boost::circular_buffer buf) { + auto sum = std::accumulate(buf.begin(), buf.end(), (double)0); + return sum / (double)buf.size(); + } // high_average (and subsequenly low_average) below, is simply adding up the // contents of the highs (or lows) and dividing it by the number of elements [[nodiscard]] std::optional high_average() const { if (!has_data()) { return std::nullopt; } - auto h_sum = std::accumulate(highs.begin(), highs.end(), (double)0); - return h_sum / (double)highs.size(); + if (use_hma) { + return weighted_moving_average(high_mma, high_mma.size()); + } + return simple_Avg(highs); } [[nodiscard]] std::optional low_average() const { if (!has_data()) { return std::nullopt; } - auto l_sum = std::accumulate(lows.begin(), lows.end(), (double)0); - return l_sum / (double)lows.size(); + if (use_hma) { + return weighted_moving_average(low_mma, low_mma.size()); + } + return simple_Avg(lows); } [[nodiscard]] bool lwr_has_data() const { return lows.size() >= lwr_buffer_sz; @@ -477,8 +522,15 @@ struct GanData { [[nodiscard]] bool upr_has_data() const { return highs.size() >= upr_buffer_sz; } + [[nodiscard]] bool lwr_mma_has_data() const { + return low_mma.size() >= lwr_mma_sz; + } + [[nodiscard]] bool upr_mma_has_data() const { + return high_mma.size() >= upr_mma_sz; + } [[nodiscard]] bool has_data() const { - return lwr_has_data() && upr_has_data(); + return use_hma ? lwr_mma_has_data() && upr_mma_has_data() + : lwr_has_data() && upr_has_data(); } }; @@ -505,7 +557,7 @@ struct MomentumAlgoParams { const double cash_per_point; const TimeHandler start_time, end_time; const bool log_graph, file_read, fixed_edge_gain, fixed_edge_loss, - reverse_logic, timed_start, early_brick; + reverse_logic, timed_start, early_brick, hull_avg; MomentumAlgoParams(SecurityKey security_key_id, size_t renko_ticks, size_t edge_ticks_gain_limit, size_t edge_ticks_loss_limit, size_t upr_gan_buffer_sz, @@ -515,7 +567,7 @@ struct MomentumAlgoParams { bool file_read, bool fixed_edge_gain, bool fixed_edge_loss, bool reverse_logic, bool timed_start, bool log_graph, bool early_brick, - double early_threshold) + double early_threshold, bool hull_avg) : security_key_id(security_key_id), security_name_str(security_name_str), renko_ticks(renko_ticks), edge_ticks_gain_limit(edge_ticks_gain_limit), edge_ticks_loss_limit(edge_ticks_loss_limit), @@ -525,7 +577,8 @@ struct MomentumAlgoParams { start_time(start_time), end_time(end_time), log_graph(log_graph), file_read(file_read), fixed_edge_gain(fixed_edge_gain), fixed_edge_loss(fixed_edge_loss), reverse_logic(reverse_logic), - timed_start(timed_start), early_brick(early_brick) {} + timed_start(timed_start), early_brick(early_brick), + hull_avg(hull_avg) {} std::string print() { std::string sep_obj = ", "; std::string sep_key_val = ":"; @@ -552,6 +605,7 @@ struct MomentumAlgoParams { add_to_s("fixed_edge_loss", std::to_string(fixed_edge_loss)); add_to_s("reverse_logic", std::to_string(reverse_logic)); add_to_s("timed_start", std::to_string(timed_start)); + add_to_s("hull avg", std::to_string(hull_avg)); return s; } }; @@ -643,6 +697,7 @@ bool _convert_params(IBeforeLaunchAlgoServices &serv, auto timed_start = get_if(params, "Timed Start?"); auto log_graph = get_if(params, "Log Graph?"); auto early_brick = get_if(params, "Early Brick?"); + auto hull_avg = get_if(params, "Use Hull Avg?"); auto renko_ticks = get_if(params, "Renko Ticks"); auto upr_gan_buffer_sz = get_if(params, "Upper Gan Buffer Size"); @@ -680,21 +735,21 @@ bool _convert_params(IBeforeLaunchAlgoServices &serv, !open_position_on_close.has_value() || !edge_ticks_gain_limit.has_value() || !edge_ticks_loss_limit.has_value() || !run_duration.has_value() || - (timed_start.value() && !check_time())) { + !hull_avg.has_value() || (timed_start.value() && !check_time())) { LOG(OrderMan, Info, "MomentumAlgo::convert_params failed edge_target:{}, edge_loss:{}, " "reverse_logic:{}, timed_start:{}, file_sim:{},renko_ticks:{}, " "upr_gan_buffer_sz:{}, lwr_gan_buffer_sz:{}, " "open_position_on_close:{}, " "edge_ticks_gain_limit:{}, edge_ticks_loss_limit:{}, " - "run_duration:{}, check_time:{}", + "run_duration:{}, check_time:{}, hull_avg:{}", edge_target.has_value(), edge_loss.has_value(), reverse_logic.has_value(), timed_start.has_value(), file_sim.has_value(), renko_ticks.has_value(), upr_gan_buffer_sz.has_value(), lwr_gan_buffer_sz.has_value(), open_position_on_close.has_value(), edge_ticks_gain_limit.has_value(), edge_ticks_loss_limit.has_value(), run_duration.has_value(), - check_time()); + check_time(), hull_avg.has_value()); return false; } auto start_time = TimeHandler(); @@ -714,7 +769,8 @@ bool _convert_params(IBeforeLaunchAlgoServices &serv, edge_target.value(), edge_loss.value(), reverse_logic.value(), timed_start.value(), log_graph.has_value() ? log_graph.value() : true, early_brick.has_value() ? early_brick.value() : false, - early_threshold.has_value() ? early_threshold.value() : 0)); + early_threshold.has_value() ? early_threshold.value() : 0, + hull_avg.value())); return true; } @@ -765,8 +821,9 @@ void MomentumAlgo::do_launch(IAlgoServices &algo_services) { // id will be id and security id me->renko = std::make_unique( Renko(me->renko_tick_size, me->algo_params->renko_ticks)); - me->gandata = std::make_unique(GanData( - me->algo_params->upr_gan_buffer_sz, me->algo_params->lwr_gan_buffer_sz)); + me->gandata = std::make_unique( + GanData(me->algo_params->upr_gan_buffer_sz, + me->algo_params->lwr_gan_buffer_sz, me->algo_params->hull_avg)); if (me->algo_params->file_read) { me->sim = std::make_unique( me->algo_params->start_time, me->algo_params->security_name_str); @@ -860,11 +917,13 @@ void MomentumAlgo::_early_brick() { auto new_low_brick = me->renko->current_brick->check_bounds(new_low_price); auto new_high_avg = me->gandata->high_average_hyp(new_high_brick); auto new_low_avg = me->gandata->low_average_hyp(new_low_brick); - bool sell_signal = new_low_avg.has_value() - ? new_low_brick.value().low >= new_low_price + bool sell_signal = new_low_avg.has_value() && new_high_avg.has_value() + ? new_high_avg > new_low_avg && + new_low_brick.value().low <= new_low_avg : false; - bool buy_signal = new_high_avg.has_value() - ? new_high_brick.value().high >= new_high_price + bool buy_signal = new_high_avg.has_value() && new_high_avg.has_value() + ? new_high_avg > new_low_avg && + new_high_brick.value().high >= new_high_avg : false; if (me->algo_params->reverse_logic) { auto temp = buy_signal; @@ -945,8 +1004,8 @@ void MomentumAlgo::_analyze_trade() { auto low_avg = me->gandata->low_average().value(); auto high_avg = me->gandata->high_average().value(); auto edges = me->renko->current_brick->edges; - bool buy_signal = edges.high >= high_avg; - bool sell_signal = edges.low <= low_avg; + bool buy_signal = high_avg > low_avg && edges.high >= high_avg; + bool sell_signal = high_avg > low_avg && edges.low <= low_avg; if (me->algo_params->reverse_logic) { auto temp = buy_signal; buy_signal = sell_signal; diff --git a/src/lib/orderman/orders/algo/algo_orders/RegisterDorman.cpp b/src/lib/orderman/orders/algo/algo_orders/RegisterDorman.cpp index e9af70738..da3afdf12 100644 --- a/src/lib/orderman/orders/algo/algo_orders/RegisterDorman.cpp +++ b/src/lib/orderman/orders/algo/algo_orders/RegisterDorman.cpp @@ -267,6 +267,7 @@ extern "C" void init_momentum_algo_plugin(bts::SparkServices &srv) { *momentum.add_param_desc() = param_bool("Timed Start?"); *momentum.add_param_desc() = param_bool("Log Graph?"); *momentum.add_param_desc() = param_bool("Early Brick?"); + *momentum.add_param_desc() = param_bool("Use Hull Avg?"); // *momentum.add_param_desc() = param_string("time( 24H HHMM)"); *momentum.add_param_desc() = param_uint32("Renko Ticks");