fx Namespace Reference

Core routines that don't depend on any other fx routines. More...

Functions
template<typename T = size_t>
constexpr T	to_size (std::ranges::range auto &&xs)
	Calculate size of a series, return type depends on input param.
constexpr auto	to_first (std::ranges::range auto &&xs)
	Return the first entry in a series.
constexpr auto	to_sum (std::ranges::range auto &&xs)
	Calculate sum of series.
constexpr auto	to_sum2 (std::ranges::range auto &&xs)
	Calculate sum of series.
constexpr auto	to_profit (auto &&entry, auto &&exit)
	Calculate profit from a trade.
void	BM_is_entry (benchmark::State &state)
void	BM_is_entry2 (benchmark::State &state)
void	BM_to_exit (benchmark::State &state)
void	BM_to_exit2 (benchmark::State &state)
void	BM_to_vwap (benchmark::State &state)
void	BM_to_vwap2 (benchmark::State &state)
void	BM_to_atr (benchmark::State &state)
void	BM_to_atr2 (benchmark::State &state)
void	BM_to_atr3 (benchmark::State &state)
void	BM_is_recent_dip2 (benchmark::State &state)
void	BM_to_average_func (benchmark::State &state)
void	BM_to_average_func2 (benchmark::State &state)
void	BM_to_average_volume (benchmark::State &state)
void	BM_to_average_volume2 (benchmark::State &state)
	BENCHMARK (BM_is_entry)
	BENCHMARK (BM_is_entry2)
	BENCHMARK (BM_to_exit)
	BENCHMARK (BM_to_exit2)
	BENCHMARK (BM_to_vwap)
	BENCHMARK (BM_to_vwap2)
	BENCHMARK (BM_is_recent_dip2)
	BENCHMARK (BM_to_atr)
	BENCHMARK (BM_to_atr2)
	BENCHMARK (BM_to_atr3)
	BENCHMARK (BM_to_average_func)
	BENCHMARK (BM_to_average_func2)
	BENCHMARK (BM_to_average_volume)
	BENCHMARK (BM_to_average_volume2)
void	BM_to_size (benchmark::State &state)
void	BM_to_first (benchmark::State &state)
void	BM_to_last (benchmark::State &state)
void	BM_to_sum (benchmark::State &state)
void	BM_to_sum2 (benchmark::State &state)
void	BM_to_spot (benchmark::State &state)
void	BM_identity (benchmark::State &state)
void	BM_identity2 (benchmark::State &state)
void	BM_to_profit (benchmark::State &state)
	BENCHMARK (BM_to_size)
	BENCHMARK (BM_to_first)
	BENCHMARK (BM_to_last)
	BENCHMARK (BM_to_sum)
	BENCHMARK (BM_to_sum2)
	BENCHMARK (BM_to_spot)
	BENCHMARK (BM_identity)
	BENCHMARK (BM_identity2)
	BENCHMARK (BM_to_profit)
void	BM_to_time (benchmark::State &state)
void	BM_to_open (benchmark::State &state)
void	BM_to_high (benchmark::State &state)
void	BM_to_low (benchmark::State &state)
void	BM_to_close (benchmark::State &state)
void	BM_to_volume (benchmark::State &state)
	BENCHMARK (BM_to_time)
	BENCHMARK (BM_to_open)
	BENCHMARK (BM_to_high)
	BENCHMARK (BM_to_low)
	BENCHMARK (BM_to_close)
	BENCHMARK (BM_to_volume)
constexpr auto	to_time (std::ranges::range auto &&xs)
	Get time of a data point.
constexpr auto	to_open (std::ranges::range auto &&xs)
	Get open price for a data point.
constexpr auto	to_high (std::ranges::range auto &&xs)
	Get high price for a data point.
constexpr auto	to_low (std::ranges::range auto &&xs)
	Get low price for a data point.
constexpr auto	to_close (std::ranges::range auto &&xs)
	Get close price for a data point.
constexpr auto	to_atr (auto &&series)
	Calculate ATR of a series.
constexpr auto	to_atr2 (auto &&series)
	Calculate ATR of a series.
constexpr double	to_atr3 (auto &&series)
	Calculate ATR of a series.
constexpr double	to_vwap (std::ranges::range auto &&xs)
	Calculate VWAP rolling average.
constexpr double	to_vwap2 (std::ranges::range auto &&xs)
	Calculate VWAP rolling average.
auto	is_recent_dip2 (auto &&series)
	Test if there has been a recent minimum.

Variables
constexpr auto	win {68uz}
	The number of prices in a trading window.
constexpr auto	win2 {34uz}
constexpr auto	win4 {17uz}
constexpr auto	take_profit {3.0}
	Close position if price has increased by this percentage.
constexpr auto	stop_loss {take_profit * 2.0}
	Close position if price has decreased by this percentage.
constexpr auto	minimum_entry {4.3}
	Minimum price to consider a trade.
constexpr auto	minimum_atr {take_profit / 6.0}
	Minimum (normalised) ATR to consider a trade.
constexpr auto	cells {6uz}
	Number of cells in a row of price data.
constexpr auto	earliest_entry_epoch {1689798790}
	Furthest back in time to consider a trade.
constexpr auto	to_last
	Return the last entry in a series.
constexpr auto	identity = [](auto &&xs) { return xs; }
	Just passing through.
constexpr auto	identity2
	Just passing through.
constexpr auto	to_volume
	Get total volume for a data point.
constexpr auto	to_average_func
constexpr auto	to_average_func2
constexpr auto	to_spot
	Calculate spot value, note we don't average all of the OHLC prices.
constexpr auto	to_average_volume
	Calculate average volume over a series.
constexpr auto	to_average_volume2
	Calculate average volume over a series.
auto	to_exit
	Find an exit in a series.
auto	to_exit2
	Find an exit in a series.
auto	is_entry
	Calculate if the final price is an entry.
auto	is_entry2
	Calculate if the final price is an entry.

Detailed Description

Core routines that don't depend on any other fx routines.

Function Documentation

BENCHMARK() [1/29]

fx::BENCHMARK

(

BM_identity

)

Here is the call graph for this function:

BENCHMARK() [2/29]

fx::BENCHMARK

(

BM_identity2

)

Here is the call graph for this function:

BENCHMARK() [3/29]

fx::BENCHMARK

(

BM_is_entry

)

Here is the call graph for this function:

BENCHMARK() [4/29]

fx::BENCHMARK

(

BM_is_entry2

)

Here is the call graph for this function:

BENCHMARK() [5/29]

fx::BENCHMARK

(

BM_is_recent_dip2

)

Here is the call graph for this function:

BENCHMARK() [6/29]

fx::BENCHMARK

(

BM_to_atr

)

Here is the call graph for this function:

BENCHMARK() [7/29]

fx::BENCHMARK

(

BM_to_atr2

)

Here is the call graph for this function:

BENCHMARK() [8/29]

fx::BENCHMARK

(

BM_to_atr3

)

Here is the call graph for this function:

BENCHMARK() [9/29]

fx::BENCHMARK

(

BM_to_average_func

)

Here is the call graph for this function:

BENCHMARK() [10/29]

fx::BENCHMARK

(

BM_to_average_func2

)

Here is the call graph for this function:

BENCHMARK() [11/29]

fx::BENCHMARK

(

BM_to_average_volume

)

Here is the call graph for this function:

BENCHMARK() [12/29]

fx::BENCHMARK

(

BM_to_average_volume2

)

Here is the call graph for this function:

BENCHMARK() [13/29]

fx::BENCHMARK

(

BM_to_close

)

Here is the call graph for this function:

BENCHMARK() [14/29]

fx::BENCHMARK

(

BM_to_exit

)

Here is the call graph for this function:

BENCHMARK() [15/29]

fx::BENCHMARK

(

BM_to_exit2

)

Here is the call graph for this function:

BENCHMARK() [16/29]

fx::BENCHMARK

(

BM_to_first

)

Here is the call graph for this function:

BENCHMARK() [17/29]

fx::BENCHMARK

(

BM_to_high

)

Here is the call graph for this function:

BENCHMARK() [18/29]

fx::BENCHMARK

(

BM_to_last

)

Here is the call graph for this function:

BENCHMARK() [19/29]

fx::BENCHMARK

(

BM_to_low

)

Here is the call graph for this function:

BENCHMARK() [20/29]

fx::BENCHMARK

(

BM_to_open

)

Here is the call graph for this function:

BENCHMARK() [21/29]

fx::BENCHMARK

(

BM_to_profit

)

Here is the call graph for this function:

BENCHMARK() [22/29]

fx::BENCHMARK

(

BM_to_size

)

Here is the call graph for this function:

BENCHMARK() [23/29]

fx::BENCHMARK

(

BM_to_spot

)

Here is the call graph for this function:

BENCHMARK() [24/29]

fx::BENCHMARK

(

BM_to_sum

)

Here is the call graph for this function:

BENCHMARK() [25/29]

fx::BENCHMARK

(

BM_to_sum2

)

Here is the call graph for this function:

BENCHMARK() [26/29]

fx::BENCHMARK

(

BM_to_time

)

Here is the call graph for this function:

BENCHMARK() [27/29]

fx::BENCHMARK

(

BM_to_volume

)

Here is the call graph for this function:

BENCHMARK() [28/29]

fx::BENCHMARK

(

BM_to_vwap

)

Here is the call graph for this function:

BENCHMARK() [29/29]

fx::BENCHMARK

(

BM_to_vwap2

)

Here is the call graph for this function:

BM_identity()

void fx::BM_identity

(

benchmark::State &

state

)

Definition at line 162 of file main.cxx.

                                        {
  for (auto _ : state)
    benchmark::DoNotOptimize(identity(xs3));
}

Here is the caller graph for this function:

BM_identity2()

void fx::BM_identity2

(

benchmark::State &

state

)

Definition at line 167 of file main.cxx.

                                         {
  for (auto _ : state)
    benchmark::DoNotOptimize(identity2(xs3));
}

Here is the caller graph for this function:

BM_is_entry()

void fx::BM_is_entry

(

benchmark::State &

state

)

Definition at line 41 of file main.cxx.

                                        {
  for (auto _ : state)
    benchmark::DoNotOptimize(
        std::ranges::for_each(xs | slide(win) | filter(is_entry), [](auto) {}));
}

Here is the caller graph for this function:

BM_is_entry2()

void fx::BM_is_entry2

(

benchmark::State &

state

)

Definition at line 47 of file main.cxx.

                                         {
  for (auto _ : state)
    benchmark::DoNotOptimize(std::ranges::for_each(
        xs | slide(win) | filter(is_entry2), [](auto) {}));
}

Here is the caller graph for this function:

BM_is_recent_dip2()

void fx::BM_is_recent_dip2

(

benchmark::State &

state

)

Definition at line 88 of file main.cxx.

                                              {
  for (auto _ : state)
    benchmark::DoNotOptimize(is_recent_dip2(xs | take(win)));
}

Here is the call graph for this function:

Here is the caller graph for this function:

BM_to_atr()

void fx::BM_to_atr

(

benchmark::State &

state

)

Definition at line 73 of file main.cxx.

                                      {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_atr(xs));
}

Here is the call graph for this function:

Here is the caller graph for this function:

BM_to_atr2()

void fx::BM_to_atr2

(

benchmark::State &

state

)

Definition at line 78 of file main.cxx.

                                       {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_atr2(xs));
}

Here is the call graph for this function:

Here is the caller graph for this function:

BM_to_atr3()

void fx::BM_to_atr3

(

benchmark::State &

state

)

Definition at line 83 of file main.cxx.

                                       {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_atr3(xs));
}

Here is the call graph for this function:

Here is the caller graph for this function:

BM_to_average_func()

void fx::BM_to_average_func

(

benchmark::State &

state

)

Definition at line 93 of file main.cxx.

                                               {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_average_func(xs3, identity));
}

Here is the caller graph for this function:

BM_to_average_func2()

void fx::BM_to_average_func2

(

benchmark::State &

state

)

Definition at line 98 of file main.cxx.

                                                {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_average_func2(xs3, identity));
}

Here is the caller graph for this function:

BM_to_average_volume()

void fx::BM_to_average_volume

(

benchmark::State &

state

)

Definition at line 103 of file main.cxx.

                                                 {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_average_volume(xs));
}

Here is the caller graph for this function:

BM_to_average_volume2()

void fx::BM_to_average_volume2

(

benchmark::State &

state

)

Definition at line 108 of file main.cxx.

                                                  {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_average_volume2(xs));
}

Here is the caller graph for this function:

BM_to_close()

void fx::BM_to_close

(

benchmark::State &

state

)

Definition at line 211 of file main.cxx.

                                        {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_close(xs2));
}

Here is the call graph for this function:

Here is the caller graph for this function:

BM_to_exit()

void fx::BM_to_exit

(

benchmark::State &

state

)

Definition at line 53 of file main.cxx.

                                       {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_exit(xs | take(win)));
}

Here is the caller graph for this function:

BM_to_exit2()

void fx::BM_to_exit2

(

benchmark::State &

state

)

Definition at line 58 of file main.cxx.

                                        {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_exit2(xs | take(win)));
}

Here is the caller graph for this function:

BM_to_first()

void fx::BM_to_first

(

benchmark::State &

state

)

Definition at line 137 of file main.cxx.

                                        {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_first(xs2));
}

Here is the call graph for this function:

Here is the caller graph for this function:

BM_to_high()

void fx::BM_to_high

(

benchmark::State &

state

)

Definition at line 201 of file main.cxx.

                                       {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_high(xs2));
}

Here is the call graph for this function:

Here is the caller graph for this function:

BM_to_last()

void fx::BM_to_last

(

benchmark::State &

state

)

Definition at line 142 of file main.cxx.

                                       {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_last(xs2));
}

Here is the caller graph for this function:

BM_to_low()

void fx::BM_to_low

(

benchmark::State &

state

)

Definition at line 206 of file main.cxx.

                                      {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_low(xs2));
}

Here is the call graph for this function:

Here is the caller graph for this function:

BM_to_open()

void fx::BM_to_open

(

benchmark::State &

state

)

Definition at line 196 of file main.cxx.

                                       {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_open(xs2));
}

Here is the call graph for this function:

Here is the caller graph for this function:

BM_to_profit()

void fx::BM_to_profit

(

benchmark::State &

state

)

Definition at line 172 of file main.cxx.

                                         {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_profit(100.0, 110.0));
}

Here is the call graph for this function:

Here is the caller graph for this function:

BM_to_size()

void fx::BM_to_size

(

benchmark::State &

state

)

Definition at line 132 of file main.cxx.

                                       {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_size(xs));
}

Here is the call graph for this function:

Here is the caller graph for this function:

BM_to_spot()

void fx::BM_to_spot

(

benchmark::State &

state

)

Definition at line 157 of file main.cxx.

                                       {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_spot(xs2));
}

Here is the caller graph for this function:

BM_to_sum()

void fx::BM_to_sum

(

benchmark::State &

state

)

Definition at line 147 of file main.cxx.

                                      {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_sum(xs3));
}

Here is the call graph for this function:

Here is the caller graph for this function:

BM_to_sum2()

void fx::BM_to_sum2

(

benchmark::State &

state

)

Definition at line 152 of file main.cxx.

                                       {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_sum2(xs3));
}

Here is the call graph for this function:

Here is the caller graph for this function:

BM_to_time()

void fx::BM_to_time

(

benchmark::State &

state

)

Definition at line 191 of file main.cxx.

                                       {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_time(xs2));
}

Here is the call graph for this function:

Here is the caller graph for this function:

BM_to_volume()

void fx::BM_to_volume

(

benchmark::State &

state

)

Definition at line 216 of file main.cxx.

                                         {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_volume(xs2));
}

Here is the caller graph for this function:

BM_to_vwap()

void fx::BM_to_vwap

(

benchmark::State &

state

)

Definition at line 63 of file main.cxx.

                                       {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_vwap(xs));
}

Here is the call graph for this function:

Here is the caller graph for this function:

BM_to_vwap2()

void fx::BM_to_vwap2

(

benchmark::State &

state

)

Definition at line 68 of file main.cxx.

                                        {
  for (auto _ : state)
    benchmark::DoNotOptimize(to_vwap2(xs));
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_recent_dip2()

auto fx::is_recent_dip2

(

auto &&

series

)

Test if there has been a recent minimum.

Definition at line 141 of file trade.h.

                                   {
  // Find minimum spot value
  auto &&min_it = std::ranges::min_element(
      series, [](auto &&a, auto &&b) { return to_spot(a) < to_spot(b); });
 
  // Return true if the minimum is in the middle
  return std::ranges::distance(std::ranges::begin(series), min_it) ==
         to_size<ssize_t>(series) / 2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

to_atr()

auto fx::to_atr ( auto && series )

constexpr

Calculate ATR of a series.

Definition at line 43 of file trade.h.

                                     {
  // Get all adjacent pairs
  auto pairs = series | slide(2);
 
  // Calculate the true price and volume
  auto true_ranges = pairs | transform([](auto px) {
                       assert(to_size(px) == 2);
                       auto a = px[0];
                       auto b = px[1];
                       auto tr_high = std::abs(to_high(b) - to_close(a));
                       auto tr_low = std::abs(to_low(b) - to_close(a));
                       return (tr_high + tr_low) / 2.0;
                     });
 
  // Calculate average true range
  return to_average_func(true_ranges, identity);
}

Here is the call graph for this function:

Here is the caller graph for this function:

to_atr2()

auto fx::to_atr2 ( auto && series )

constexpr

Calculate ATR of a series.

Definition at line 62 of file trade.h.

                                      {
  // Get all adjacent pairs
  auto pairs = series | slide(2);
 
  // Calculate the true price and volume
  auto true_ranges = pairs | transform([](auto &&px) {
                       assert(to_size(px) == 2);
                       auto &&a = px[0];
                       auto &&b = px[1];
                       auto &&tr_high = std::abs(to_high(b) - to_close(a));
                       auto &&tr_low = std::abs(to_low(b) - to_close(a));
                       return (tr_high + tr_low) / 2.0;
                     });
 
  // Calculate average true range
  return to_average_func(true_ranges, identity);
}

Here is the call graph for this function:

Here is the caller graph for this function:

to_atr3()

double fx::to_atr3 ( auto && series )

constexpr

Calculate ATR of a series.

Definition at line 81 of file trade.h.

                                        {
  // Get all adjacent pairs
  auto &&pairs = series | slide(2);
 
  // Calculate the true price and volume
  auto &&true_ranges = pairs | transform([](auto &&px) {
                         assert(to_size(px) == 2);
                         auto &&a = px[0];
                         auto &&b = px[1];
                         auto &&tr_high = std::abs(to_high(b) - to_close(a));
                         auto &&tr_low = std::abs(to_low(b) - to_close(a));
                         return (tr_high + tr_low) / double{2.0f};
                       });
 
  // Calculate average true range
  return to_average_func(true_ranges, [](auto &&x) { return x; });
}

Here is the call graph for this function:

Here is the caller graph for this function:

to_close()

auto fx::to_close ( std::ranges::range auto && xs )

constexpr

Get close price for a data point.

Definition at line 32 of file ohlc.h.

                                                  {
  assert(to_size(xs) > 4uz);
  return xs[4];
}

Here is the call graph for this function:

Here is the caller graph for this function:

to_first()

auto fx::to_first ( std::ranges::range auto && xs )

constexpr

Return the first entry in a series.

Definition at line 19 of file core.h.

                                                  {
  assert(not std::ranges::empty(xs));
  return xs[0];
}

Here is the caller graph for this function:

to_high()

auto fx::to_high ( std::ranges::range auto && xs )

constexpr

Get high price for a data point.

Definition at line 20 of file ohlc.h.

                                                 {
  assert(to_size(xs) > 2uz);
  return xs[2];
}

Here is the call graph for this function:

Here is the caller graph for this function:

to_low()

auto fx::to_low ( std::ranges::range auto && xs )

constexpr

Get low price for a data point.

Definition at line 26 of file ohlc.h.

                                                {
  assert(to_size(xs) > 3uz);
  return xs[3];
}

Here is the call graph for this function:

Here is the caller graph for this function:

to_open()

auto fx::to_open ( std::ranges::range auto && xs )

constexpr

Get open price for a data point.

Definition at line 14 of file ohlc.h.

                                                 {
  assert(to_size(xs) > 1uz);
  return xs[1];
}

Here is the call graph for this function:

Here is the caller graph for this function:

to_profit()

auto fx::to_profit ( auto && entry, auto && exit )

constexpr

Calculate profit from a trade.

Definition at line 59 of file core.h.

                                                    {
  auto &&profit = decltype(entry){100.0f} * (exit - entry) / entry;
 
  static_assert(std::is_same_v<decltype(entry), decltype(exit)>);
  static_assert(std::is_same_v<decltype(profit), decltype(entry)>);
 
  return profit;
}

Here is the caller graph for this function:

to_size()

template<typename T = size_t>

T fx::to_size ( std::ranges::range auto && xs )

constexpr

Calculate size of a series, return type depends on input param.

Definition at line 14 of file core.h.

                                              {
  return static_cast<T>(std::ranges::size(xs));
}

Here is the caller graph for this function:

to_sum()

auto fx::to_sum ( std::ranges::range auto && xs )

constexpr

Calculate sum of series.

Definition at line 31 of file core.h.

                                                {
  return std::ranges::fold_left(
      xs, 0.0, [](const double acc, double x) { return acc + x; });
}

Here is the caller graph for this function:

to_sum2()

auto fx::to_sum2 ( std::ranges::range auto && xs )

constexpr

Calculate sum of series.

Definition at line 37 of file core.h.

                                                 {
  assert(not std::ranges::empty(xs));
 
  const auto &&sum = std::ranges::fold_left(
      xs, decltype(xs[0]){}, [](auto acc, auto &&x) { return acc + x; });
 
  // Check the type of the first element is the same as the sum
  static_assert(std::is_same_v<std::remove_cvref_t<decltype(xs[0])>,
                               std::remove_cvref_t<decltype(sum)>>);
 
  return sum;
}

Here is the caller graph for this function:

to_time()

auto fx::to_time ( std::ranges::range auto && xs )

constexpr

Get time of a data point.

Definition at line 9 of file ohlc.h.

                                                 {
  return std::lround(to_first(xs));
};

Here is the call graph for this function:

Here is the caller graph for this function:

to_vwap()

double fx::to_vwap ( std::ranges::range auto && xs )

constexpr

Calculate VWAP rolling average.

Definition at line 110 of file trade.h.

                                                   {
  // Initialise cumulative volumes
  auto cumulative_tp_volume = 0.0;
  auto cumulative_volume = 0.0;
 
  // Calculate VWAP for each sliding window
  for (auto &&x : xs) {
    cumulative_tp_volume += to_spot(x) * to_volume(x);
    cumulative_volume += to_volume(x);
  }
 
  return cumulative_tp_volume / cumulative_volume;
}

Here is the caller graph for this function:

to_vwap2()

double fx::to_vwap2 ( std::ranges::range auto && xs )

constexpr

Calculate VWAP rolling average.

Definition at line 125 of file trade.h.

                                                    {
  // Initialise cumulative volumes
  auto &&cumulative_tp_volume = 0.0;
  auto &&cumulative_volume = 0.0;
 
  // Calculate VWAP for each sliding window
  for (auto &&x : xs) {
    auto &&vol = to_volume(x);
    cumulative_tp_volume += to_spot(x) * vol;
    cumulative_volume += vol;
  }
 
  return cumulative_tp_volume / cumulative_volume;
}

Here is the caller graph for this function:

Variable Documentation

cells

auto fx::cells {6uz}

constexpr

Number of cells in a row of price data.

Definition at line 23 of file constants.h.

{6uz};

earliest_entry_epoch

auto fx::earliest_entry_epoch {1689798790}

constexpr

Furthest back in time to consider a trade.

Definition at line 26 of file constants.h.

{1689798790};

identity

auto fx::identity = [](auto &&xs) { return xs; }

constexpr

Just passing through.

Definition at line 51 of file core.h.

{ return xs; };

identity2

auto fx::identity2

constexpr

Initial value:

= [](auto &&xs) {
  return std::forward<decltype(xs)>(xs);
}

Just passing through.

Definition at line 54 of file core.h.

                                         {
  return std::forward<decltype(xs)>(xs);
};

is_entry

auto fx::is_entry

Calculate if the final price is an entry.

Definition at line 199 of file trade.h.

                                                 {
  // Create subsets of complete series
  const auto last_half =
      series | drop(std::llround(to_size<double>(series) / 2.0));
  const auto last_quarter =
      series | drop(std::llround(to_size<double>(series) * 3.0 / 4.0));
 
  // Copy the final price: the entry point
  const auto entry = to_last(series);
 
  // Test all the criteria for a trade
  return
      // No small change
      to_spot(entry) > fx::minimum_entry
 
      // Above minimum ATR
      and (100.0 * to_atr3(series) / to_spot(entry)) > fx::minimum_atr
 
      // Average volume is used to determine if the last price is a spike
      and
      to_volume(entry) > to_average_volume(series | take(to_size(series) - 1))
 
      // There has been a recent minimum
      and is_recent_dip2(last_quarter)
 
      // Price is below the long VWAP
      and to_spot(entry) < to_vwap(series)
 
      // Short VWAP is above the long VWAP
      and to_vwap(last_half) > to_vwap(series);
};

is_entry2

auto fx::is_entry2

Calculate if the final price is an entry.

Definition at line 232 of file trade.h.

                                                  {
  assert(not std::ranges::empty(series));
 
  // Create subsets of complete series
  // Using reverse simplifies the drop logic
  auto &&last_half = series | reverse | take(fx::win2) | reverse;
  auto &&last_quarter = series | reverse | take(fx::win4) | reverse;
 
  // Copy the final price: the entry point
  auto &&entry = to_last(series);
 
  // Test all the criteria for a trade
  return
 
      // No old trades
      to_time(entry) > fx::earliest_entry_epoch
 
      // No small change
      and to_spot(entry) > fx::minimum_entry
 
      // Above minimum ATR
      and (100.0 * to_atr3(series) / to_spot(entry)) > fx::minimum_atr
 
      // Average volume is used to determine if the last price is a spike
      and to_volume(entry) >
              to_average_volume(series | reverse | drop(1uz) | reverse)
 
      // There has been a recent minimum
      and is_recent_dip2(last_quarter)
 
      // Price is below the long VWAP
      and to_spot(entry) < to_vwap(series)
 
      // Short VWAP is above the long VWAP
      and to_vwap(last_half) > to_vwap(series);
};

minimum_atr

auto fx::minimum_atr {take_profit / 6.0}

constexpr

Minimum (normalised) ATR to consider a trade.

Definition at line 20 of file constants.h.

{take_profit / 6.0};

minimum_entry

auto fx::minimum_entry {4.3}

constexpr

Minimum price to consider a trade.

Definition at line 17 of file constants.h.

{4.3};

stop_loss

auto fx::stop_loss {take_profit * 2.0}

constexpr

Close position if price has decreased by this percentage.

Definition at line 14 of file constants.h.

{take_profit * 2.0};

take_profit

auto fx::take_profit {3.0}

constexpr

Close position if price has increased by this percentage.

Definition at line 11 of file constants.h.

{3.0};

to_average_func

auto fx::to_average_func

constexpr

Initial value:

= [](auto &&xs, auto func) {
  assert(not std::ranges::empty(xs));
  return to_sum(xs | transform(func)) / to_size(xs);
}

Calculate average of series, applying a function to each element (which could be a no-op)

Definition at line 16 of file trade.h.

                                                          {
  assert(not std::ranges::empty(xs));
  return to_sum(xs | transform(func)) / to_size(xs);
};

to_average_func2

auto fx::to_average_func2

constexpr

Initial value:

= [](auto &&xs, auto &&func) {
  assert(not std::ranges::empty(xs));
 
  auto &&sum =
      std::ranges::fold_left(xs | transform(func), 0.0,
                             [](const auto acc, auto x) { return acc + x; });
 
  return sum;
}

Definition at line 21 of file trade.h.

                                                             {
  assert(not std::ranges::empty(xs));
 
  auto &&sum =
      std::ranges::fold_left(xs | transform(func), 0.0,
                             [](const auto acc, auto x) { return acc + x; });
 
  return sum;
};

to_average_volume

auto fx::to_average_volume

constexpr

Initial value:

= [](auto series) {
  return to_average_func(series, to_volume);
}

Calculate average volume over a series.

Definition at line 100 of file trade.h.

                                                   {
  return to_average_func(series, to_volume);
};

to_average_volume2

auto fx::to_average_volume2

constexpr

Initial value:

= [](auto &&series) {
  return to_average_func2(series, to_volume);
}

Calculate average volume over a series.

Definition at line 105 of file trade.h.

                                                      {
  return to_average_func2(series, to_volume);
};

to_exit

auto fx::to_exit

Initial value:

= [](auto &&series) {
  
  const double open_price = to_spot(to_first(series));
  const double take_price = open_price * (100.0 + take_profit) / 100.0;
  const double stop_price = open_price * (100.0 - stop_loss) / 100.0;
 
  
  auto to_trunc =
      series | drop_while([=](auto &&xs) {
        const double close_price = to_spot(xs);
        return close_price > stop_price and close_price < take_price;
      }) |
      common;
 
  auto truncated = std::vector(std::begin(to_trunc), std::end(to_trunc));
 
  
  if (std::ranges::empty(truncated))
    return to_last(series);
 
  
  return to_first(truncated);
}

Find an exit in a series.

Definition at line 152 of file trade.h.

                                 {
  // Calculate the exit thresholds
  const double open_price = to_spot(to_first(series));
  const double take_price = open_price * (100.0 + take_profit) / 100.0;
  const double stop_price = open_price * (100.0 - stop_loss) / 100.0;
 
  // Drop everything up to the exit
  auto to_trunc =
      series | drop_while([=](auto &&xs) {
        const double close_price = to_spot(xs);
        return close_price > stop_price and close_price < take_price;
      }) |
      common;
 
  auto truncated = std::vector(std::begin(to_trunc), std::end(to_trunc));
 
  // If it's been truncated to nothing, then return the last price
  if (std::ranges::empty(truncated))
    return to_last(series);
 
  // Otherwise, the first price in the truncated series is the exit
  return to_first(truncated);
};

to_exit2

auto fx::to_exit2

Initial value:

= [](auto &&series) {
  
  auto &&open_price = to_spot(to_first(series));
  auto &&take_price = open_price * (100.0 + take_profit) / 100.0;
  auto &&stop_price = open_price * (100.0 - stop_loss) / 100.0;
 
  
  auto &&to_trunc =
      series | drop_while([&](auto &&xs) {
        auto &&close_price = to_spot(xs);
        return close_price > stop_price and close_price < take_price;
      }) |
      common;
 
  auto &&truncated = std::vector(std::begin(to_trunc), std::end(to_trunc));
 
  
  
  return std::ranges::empty(truncated) ? to_last(series) : to_first(truncated);
}

Find an exit in a series.

Definition at line 177 of file trade.h.

                                  {
  // Calculate the exit thresholds
  auto &&open_price = to_spot(to_first(series));
  auto &&take_price = open_price * (100.0 + take_profit) / 100.0;
  auto &&stop_price = open_price * (100.0 - stop_loss) / 100.0;
 
  // Drop everything up to the exit
  auto &&to_trunc =
      series | drop_while([&](auto &&xs) {
        auto &&close_price = to_spot(xs);
        return close_price > stop_price and close_price < take_price;
      }) |
      common;
 
  auto &&truncated = std::vector(std::begin(to_trunc), std::end(to_trunc));
 
  // If it's been truncated to nothing, then return the last price
  // Otherwise, the first price in the truncated series is the exit
  return std::ranges::empty(truncated) ? to_last(series) : to_first(truncated);
};

to_last

auto fx::to_last

constexpr

Initial value:

= [](std::ranges::range auto &&xs) {
  assert(not std::ranges::empty(xs));
  return xs[to_size(xs) - 1uz];
}

Return the last entry in a series.

Definition at line 25 of file core.h.

                                                      {
  assert(not std::ranges::empty(xs));
  return xs[to_size(xs) - 1uz];
};

to_spot

auto fx::to_spot

constexpr

Initial value:

= [](auto &&xs) {
  
  assert(to_size(xs) > 4);
 
  auto &&spot = to_average_func(xs | drop(1) | take(3), identity);
  return spot;
}

Calculate spot value, note we don't average all of the OHLC prices.

Definition at line 32 of file trade.h.

                                       {
  // Don't include the close price in the average
  assert(to_size(xs) > 4);
 
  auto &&spot = to_average_func(xs | drop(1) | take(3), identity);
  return spot;
};

to_volume

auto fx::to_volume

constexpr

Initial value:

= [](std::ranges::range auto &&xs) {
  assert(to_size(xs) > 5uz);
  return xs[5];
}

Get total volume for a data point.

Definition at line 38 of file ohlc.h.

                                                        {
  assert(to_size(xs) > 5uz);
  return xs[5];
};

win

auto fx::win {68uz}

constexpr

The number of prices in a trading window.

Definition at line 6 of file constants.h.

{68uz};

win2

auto fx::win2 {34uz}

constexpr

Definition at line 7 of file constants.h.

{34uz};

win4

auto fx::win4 {17uz}

constexpr

Definition at line 8 of file constants.h.

{17uz};