def test_naive_taxes(
self,
closes,
stop_loss,
take_profit,
target_usd_percentage,
balancing_period,
distribution,
balance,
tax_exemption,
):
distributions = np.stack([distribution, distribution], axis=1)
stop_loss_index = opt.get_stop_loss_index(closes, stop_loss)
take_profit_index = opt.get_take_profit_index(closes, take_profit)
(
usd_values_without_taxes,
asset_values_without_taxes,
_,
) = opt.get_balanced_trade_naive(
closes,
stop_loss_index,
take_profit_index,
stop_loss,
take_profit,
target_usd_percentage,
balancing_period,
orderbook_distributions=distributions,
balance=balance,
taxes=False,
)
trade_without_taxes = usd_values_without_taxes + asset_values_without_taxes
usd_values, asset_values, buy_sizes = opt.get_balanced_trade_naive(
closes,
stop_loss_index,
take_profit_index,
stop_loss,
take_profit,
target_usd_percentage,
balancing_period,
orderbook_distributions=distributions,
balance=balance,
taxes=True,
tax_exemption=tax_exemption,
)
assert np.all(usd_values >= 0.0)
assert np.all(asset_values >= 0.0)
trade = usd_values + asset_values
assert np.all(buy_sizes >= 0.0)
assert np.all(buy_sizes <= 1e-7)
if not tax_exemption:
assert np.all(trade <= trade_without_taxes)
def test_naive_spread(
self,
closes,
stop_loss,
take_profit,
target_usd_percentage,
balancing_period,
distribution,
balance,
):
assume(np.sum(distribution) > 0)
distributions = np.stack([distribution, distribution], axis=1)
stop_loss_index = opt.get_stop_loss_index(closes, stop_loss)
take_profit_index = opt.get_take_profit_index(closes, take_profit)
(
usd_values_without_spread,
asset_values_without_spread,
_,
) = opt.get_balanced_trade_naive(
closes,
stop_loss_index,
take_profit_index,
stop_loss,
take_profit,
target_usd_percentage,
balancing_period,
orderbook_distributions=distributions,
balance=0.0,
taxes=False,
)
trade_without_spread = usd_values_without_spread + asset_values_without_spread
usd_values, asset_values, _ = opt.get_balanced_trade_naive(
closes,
stop_loss_index,
take_profit_index,
stop_loss,
take_profit,
target_usd_percentage,
balancing_period,
orderbook_distributions=distributions,
balance=balance,
taxes=False,
)
assert np.all(usd_values >= 0.0)
assert np.all(asset_values >= 0.0)
trade = usd_values + asset_values
assert np.all(trade <= trade_without_spread)
def test_naive_base_case(
self,
closes,
target_usd_percentage,
):
(usd_values, asset_values, _,) = opt.get_balanced_trade_naive(
closes,
len(closes),
len(closes),
0.0,
100.0,
target_usd_percentage,
balancing_period=len(closes) + 2,
orderbook_distributions=np.array([[0.0, 0.0]]),
balance=0.0,
taxes=False,
)
assert np.all(usd_values >= 0.0)
assert np.all(asset_values >= 0.0)
trade = usd_values + asset_values
for i in range(len(closes)):
np.testing.assert_allclose(
trade[i],
closes[i] * (1.0 - target_usd_percentage) + target_usd_percentage,
)
def test_against_naive(
self,
closes,
stop_loss,
take_profit,
target_usd_percentage,
balancing_period,
distribution,
balance,
tax_exemption,
):
distributions = np.stack([distribution, distribution], axis=1)
stop_loss_index = opt.get_stop_loss_index(closes, stop_loss)
take_profit_index = opt.get_take_profit_index(closes, take_profit)
usd_values1, asset_values1, buy_sizes1 = opt.get_balanced_trade_naive(
closes,
stop_loss_index,
take_profit_index,
stop_loss,
take_profit,
target_usd_percentage,
balancing_period,
orderbook_distributions=distributions,
balance=balance,
taxes=True,
tax_exemption=tax_exemption,
)
usd_values2, asset_values2, buy_sizes2 = opt.get_balanced_trade(
closes,
stop_loss_index,
take_profit_index,
stop_loss,
take_profit,
target_usd_percentage,
balancing_period,
orderbook_distributions=distributions,
balance=balance,
taxes=True,
tax_exemption=tax_exemption,
)
np.testing.assert_allclose(usd_values1, usd_values2)
np.testing.assert_allclose(asset_values1, asset_values2)
np.testing.assert_almost_equal(buy_sizes1, buy_sizes2)
def test_naive_stop_loss_and_take_profit(
self,
closes,
stop_loss,
take_profit,
target_usd_percentage,
):
stop_loss_index = opt.get_stop_loss_index(closes, stop_loss)
take_profit_index = opt.get_take_profit_index(closes, take_profit)
usd_values, asset_values, _ = opt.get_balanced_trade_naive(
closes,
stop_loss_index,
take_profit_index,
stop_loss,
take_profit,
target_usd_percentage,
balancing_period=len(closes) + 2,
orderbook_distributions=np.array([[0.0, 0.0]]),
balance=0.0,
taxes=False,
)
assert np.all(usd_values >= 0.0)
assert np.all(asset_values >= 0.0)
trigger_i = min(stop_loss_index, take_profit_index)
triggered = trigger_i < len(closes)
trade = usd_values + asset_values
if triggered:
stop_loss_is_before_take_profit = stop_loss_index <= take_profit_index
trigger_value = (
stop_loss if stop_loss_is_before_take_profit else take_profit
)
np.testing.assert_allclose(
trade[trigger_i:],
trigger_value * (1.0 - target_usd_percentage) + target_usd_percentage,
)
def test_naive_balancing(
self,
closes,
target_usd_percentage,
balancing_period,
distribution,
balance,
taxes,
tax_exemption,
reverse,
):
assume(np.sum(distribution) > 0)
distributions = np.stack([distribution, distribution], axis=1)
closes = np.concatenate([np.ones(1), closes])
log_closes = np.log(closes)
log_closes = log_closes - (log_closes[-1] - log_closes[0]) * np.linspace(
0.0, 1.0, len(closes)
)
np.testing.assert_allclose(log_closes[0], log_closes[-1])
closes = np.exp(log_closes)
closes = closes[1:]
(
usd_values_without_balancing,
asset_values_without_balancing,
_,
) = opt.get_balanced_trade_naive(
closes,
len(closes),
len(closes),
0.0,
100.0,
target_usd_percentage,
balancing_period=len(closes) + 2,
orderbook_distributions=distributions,
balance=balance,
taxes=taxes,
tax_exemption=tax_exemption,
)
trade_without_balancing = (
usd_values_without_balancing + asset_values_without_balancing
)
usd_values, asset_values, _ = opt.get_balanced_trade_naive(
closes,
len(closes),
len(closes),
0.0,
100.0,
target_usd_percentage,
balancing_period,
orderbook_distributions=distributions,
balance=balance,
taxes=taxes,
tax_exemption=tax_exemption,
)
assert np.all(usd_values >= 0.0)
assert np.all(asset_values >= 0.0)
trade = usd_values + asset_values
rtol = 1e-7
# should be trade[-1] >= trade_without_balancing[-1]
if trade[-1] < trade_without_balancing[-1]:
np.testing.assert_allclose(
trade[-1], trade_without_balancing[-1], rtol=rtol
)
closes = np.concatenate([np.ones(1), closes])
closes = np.sort(closes)
if reverse:
closes = np.flip(closes)
closes /= closes[0]
closes = closes[1:]
(
usd_values_without_balancing,
asset_values_without_balancing,
_,
) = opt.get_balanced_trade_naive(
closes,
len(closes),
len(closes),
0.0,
100.0,
target_usd_percentage,
balancing_period=len(closes) + 2,
orderbook_distributions=distributions,
balance=balance,
taxes=taxes,
tax_exemption=tax_exemption,
)
trade_without_balancing = (
usd_values_without_balancing + asset_values_without_balancing
)
usd_values, asset_values, _ = opt.get_balanced_trade_naive(
closes,
len(closes),
len(closes),
0.0,
100.0,
target_usd_percentage,
balancing_period,
orderbook_distributions=distributions,
balance=balance,
taxes=taxes,
tax_exemption=tax_exemption,
)
assert np.all(usd_values >= 0.0)
assert np.all(asset_values >= 0.0)
trade = usd_values + asset_values
# should be trade[-1] <= trade_without_balancing[-1]
if trade[-1] > trade_without_balancing[-1]:
np.testing.assert_allclose(
trade[-1], trade_without_balancing[-1], rtol=rtol
)