added hull avg and independant hi/lo avg

This commit is contained in:
Taha Afzal committed 2023-01-31 19:42:12 -05:00
1 parent e8f98102d2
commit 49e3ec2f05
3 files changed
+85 -23

No files matched your search

@@ -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());
@@ -27,6 +27,7 @@
#include <boost/circular_buffer.hpp>
#include <boost/none.hpp>
#include <boost/tokenizer.hpp>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <ctime>
@@ -34,6 +35,7 @@
#include <functional>
#include <google/protobuf/util/time_util.h>
#include <iostream>
#include <math.h>
#include <memory>
#include <optional>
#include <ostream>
@@ -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<double> highs, lows;
boost::circular_buffer<double> 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<double> &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<double> &data) {
return 2 * weighted_moving_average(data, data.size() / 2) -
weighted_moving_average(data, data.size());
}
// for early entry exit
[[nodiscard]] std::optional<double>
high_average_hyp(std::optional<BrickEdges> 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<double> 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<double> 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<double> 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<bool>(params, "Timed Start?");
auto log_graph = get_if<bool>(params, "Log Graph?");
auto early_brick = get_if<bool>(params, "Early Brick?");
auto hull_avg = get_if<bool>(params, "Use Hull Avg?");
auto renko_ticks = get_if<uint32_t>(params, "Renko Ticks");
auto upr_gan_buffer_sz = get_if<uint32_t>(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>(
Renko(me->renko_tick_size, me->algo_params->renko_ticks));
me->gandata = std::make_unique<GanData>(GanData(
me->algo_params->upr_gan_buffer_sz, me->algo_params->lwr_gan_buffer_sz));
me->gandata = std::make_unique<GanData>(
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<SimHandler>(
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;
@@ -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");