added hull avg and independant hi/lo avg
This commit is contained in:
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");
|
||||
|
||||
Reference in new issue
Block a user