Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
polakowo
GitHub Repository: polakowo/vectorbt
 Path: blob/master/tests/notebooks/signals.ipynb
1073 views
Kernel: Python 3

signals

import vectorbt as vbt

import numpy as np
import pandas as pd
from datetime import datetime, timedelta
from numba import njit

# Disable caching for performance testing
vbt.settings.caching['enabled'] = False

accessors

index = pd.Index([
    datetime(2018, 1, 1),
    datetime(2018, 1, 2),
    datetime(2018, 1, 3),
    datetime(2018, 1, 4),
    datetime(2018, 1, 5)
])
columns = ['a', 'b', 'c']
big_index = [datetime(2018, 1, 1) + timedelta(days=i) for i in range(1000)]

entries = pd.DataFrame({
    'a': [True, False, False, False, False],
    'b': [True, False, True, False, True],
    'c': [True, True, True, False, False],
}, index=index)
print(entries.shape)

big_entries = pd.DataFrame(np.full((1000, 1000), False), index=big_index)
big_entries.iloc[::10] = True
print(big_entries.shape)
(5, 3) (1000, 1000) 
ts = pd.Series([1., 2., 3., 2., 1.], index=index, name=columns[0])
print(ts.shape)

big_ts = pd.Series(np.random.uniform(10, 13, size=(1000,)), index=big_index)
print(big_ts.shape)
(5,) (1000,) 
price = pd.DataFrame({
    'open': [10, 11, 12, 11, 10],
    'high': [11, 12, 13, 12, 11],
    'low': [9, 10, 11, 10, 9],
    'close': [10, 11, 12, 11, 10]
})

a = np.random.randint(-1, 2, size=(5, 3))
print(a.shape)

big_a = np.random.randint(-1, 2, size=(1000, 1000))
print(big_a.shape)
(5, 3) (1000, 1000) 
print(entries.vbt.signals.shuffle(seed=42))

%timeit big_entries.vbt.signals.shuffle(seed=42)
a b c 2018-01-01 False False True 2018-01-02 False False True 2018-01-03 False True False 2018-01-04 True True False 2018-01-05 False True True 11 ms ± 33.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 
print(entries.vbt.signals.fshift(2))

%timeit big_entries.vbt.signals.fshift(2)
a b c 2018-01-01 False False False 2018-01-02 False False False 2018-01-03 True True True 2018-01-04 False False True 2018-01-05 False True True 1.39 ms ± 11.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) 
print(pd.Series.vbt.signals.empty(5, index=index))
print(pd.DataFrame.vbt.signals.empty((5, 3), index=index, columns=columns))

%timeit pd.DataFrame.vbt.signals.empty((1000, 1000))
2018-01-01 False 2018-01-02 False 2018-01-03 False 2018-01-04 False 2018-01-05 False dtype: bool a b c 2018-01-01 False False False 2018-01-02 False False False 2018-01-03 False False False 2018-01-04 False False False 2018-01-05 False False False 55.7 µs ± 641 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each) 
@njit
def choice_func_nb(from_i, to_i, col):
    return np.random.choice(np.arange(from_i, to_i), size=1, replace=False)

print(pd.Series.vbt.signals.generate(5, choice_func_nb, index=index))
print(pd.DataFrame.vbt.signals.generate((5, 3), choice_func_nb, index=index, columns=columns))

%timeit pd.DataFrame.vbt.signals.generate((1000, 1000), choice_func_nb)
2018-01-01 False 2018-01-02 False 2018-01-03 False 2018-01-04 False 2018-01-05 True dtype: bool a b c 2018-01-01 False True False 2018-01-02 False False False 2018-01-03 True False True 2018-01-04 False False False 2018-01-05 False False False 12.4 ms ± 25.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 
@njit
def entry_func_nb(from_i, to_i, col, temp_int):
    temp_int[0] = from_i
    return temp_int[:1]

@njit
def exit_func_nb(from_i, to_i, col, temp_int):
    temp_int[0] = from_i
    return temp_int[:1]

temp_int = np.empty((1000,), dtype=np.int64)
en, ex = pd.Series.vbt.signals.generate_both(
    a.shape[0], entry_func_nb, (temp_int,), exit_func_nb, (temp_int,), 
    index=index)
print(en)
print(ex)
en, ex = pd.DataFrame.vbt.signals.generate_both(
    a.shape, entry_func_nb, (temp_int,), exit_func_nb, (temp_int,), 
    index=index, columns=columns)
print(en)
print(ex)
en, ex = pd.DataFrame.vbt.signals.generate_both(
    a.shape, entry_func_nb, (temp_int,), exit_func_nb, (temp_int,), 
    index=index, columns=columns, entry_wait=1, exit_wait=0)
print(en)
print(ex)
en, ex = pd.DataFrame.vbt.signals.generate_both(
    a.shape, entry_func_nb, (temp_int,), exit_func_nb, (temp_int,), 
    index=index, columns=columns, entry_wait=0, exit_wait=1)
print(en)
print(ex)

%timeit pd.DataFrame.vbt.signals.generate_both(\
    big_a.shape, entry_func_nb, (temp_int,), exit_func_nb, (temp_int,))
2018-01-01 True 2018-01-02 False 2018-01-03 True 2018-01-04 False 2018-01-05 True dtype: bool 2018-01-01 False 2018-01-02 True 2018-01-03 False 2018-01-04 True 2018-01-05 False dtype: bool a b c 2018-01-01 True True True 2018-01-02 False False False 2018-01-03 True True True 2018-01-04 False False False 2018-01-05 True True True a b c 2018-01-01 False False False 2018-01-02 True True True 2018-01-03 False False False 2018-01-04 True True True 2018-01-05 False False False a b c 2018-01-01 True True True 2018-01-02 True True True 2018-01-03 True True True 2018-01-04 True True True 2018-01-05 True True True a b c 2018-01-01 True True True 2018-01-02 True True True 2018-01-03 True True True 2018-01-04 True True True 2018-01-05 True True True a b c 2018-01-01 True True True 2018-01-02 True True True 2018-01-03 True True True 2018-01-04 True True True 2018-01-05 True True True a b c 2018-01-01 False False False 2018-01-02 True True True 2018-01-03 True True True 2018-01-04 True True True 2018-01-05 True True True 16.3 ms ± 53.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 
@njit
def choice_func_nb(from_i, to_i, col, temp_int):
    temp_int[0] = from_i
    return temp_int[:1]

print(entries.vbt.signals.generate_exits(choice_func_nb, temp_int))
print(entries.vbt.signals.generate_exits(choice_func_nb, temp_int, wait=0))

%timeit big_entries.vbt.signals.generate_exits(choice_func_nb, temp_int)
a b c 2018-01-01 False False False 2018-01-02 True True False 2018-01-03 False False False 2018-01-04 False True True 2018-01-05 False False False a b c 2018-01-01 True True True 2018-01-02 False False True 2018-01-03 False True True 2018-01-04 False False False 2018-01-05 False True False 22.1 ms ± 66.3 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) 
print(pd.Series.vbt.signals.generate_random(5, n=2, seed=42, index=index))
print(pd.DataFrame.vbt.signals.generate_random((5, 3), n=2, seed=42, index=index, columns=columns))
print(pd.DataFrame.vbt.signals.generate_random((5, 3), n=[0, 1, 2], seed=42, index=index, columns=columns))

%timeit pd.DataFrame.vbt.signals.generate_random((1000, 1000), n=100)
2018-01-01 False 2018-01-02 True 2018-01-03 False 2018-01-04 False 2018-01-05 True dtype: bool a b c 2018-01-01 False False True 2018-01-02 True True True 2018-01-03 False False False 2018-01-04 False True False 2018-01-05 True False False a b c 2018-01-01 False False True 2018-01-02 False False True 2018-01-03 False False False 2018-01-04 False True False 2018-01-05 False False False 12.6 ms ± 91.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 
print(pd.Series.vbt.signals.generate_random(5, prob=0.5, seed=42, index=index))
print(pd.DataFrame.vbt.signals.generate_random((5, 3), prob=0.5, seed=42, index=index, columns=columns))
print(pd.DataFrame.vbt.signals.generate_random((5, 3), prob=[0., 0.5, 1], seed=42, index=index, columns=columns))

%timeit pd.DataFrame.vbt.signals.generate_random((1000, 1000), prob=0.5)
2018-01-01 True 2018-01-02 False 2018-01-03 False 2018-01-04 False 2018-01-05 True dtype: bool a b c 2018-01-01 True True True 2018-01-02 False True False 2018-01-03 False False False 2018-01-04 False False True 2018-01-05 True False True a b c 2018-01-01 False True True 2018-01-02 False True True 2018-01-03 False False True 2018-01-04 False False True 2018-01-05 False False True 20 ms ± 48.7 µs per loop (mean ± std. dev. of 7 runs, 10 loops each) 
print(entries['a'].vbt.signals.generate_random_exits(seed=42))
print(entries.vbt.signals.generate_random_exits(seed=42))
print(entries.vbt.signals.generate_random_exits(seed=42, wait=0))

%timeit big_entries.vbt.signals.generate_random_exits(seed=42)
2018-01-01 False 2018-01-02 False 2018-01-03 True 2018-01-04 False 2018-01-05 False Name: a, dtype: bool a b c 2018-01-01 False False False 2018-01-02 False True False 2018-01-03 True False False 2018-01-04 False True False 2018-01-05 False False True a b c 2018-01-01 False True True 2018-01-02 True False True 2018-01-03 False False False 2018-01-04 False True True 2018-01-05 False True False 57.9 ms ± 1.05 ms per loop (mean ± std. dev. of 7 runs, 10 loops each) 
print(entries['a'].vbt.signals.generate_random_exits(prob=1., seed=42))
print(entries.vbt.signals.generate_random_exits(prob=1., seed=42))
print(entries.vbt.signals.generate_random_exits(prob=[0., 0.5, 1], seed=42))
print(entries.vbt.signals.generate_random_exits(prob=1., seed=42, wait=0))

%timeit big_entries.vbt.signals.generate_random_exits(prob=1., seed=42)
2018-01-01 False 2018-01-02 True 2018-01-03 False 2018-01-04 False 2018-01-05 False Name: a, dtype: bool a b c 2018-01-01 False False False 2018-01-02 True True False 2018-01-03 False False False 2018-01-04 False True True 2018-01-05 False False False a b c 2018-01-01 False False False 2018-01-02 False True False 2018-01-03 False False False 2018-01-04 False True True 2018-01-05 False False False a b c 2018-01-01 True True True 2018-01-02 False False True 2018-01-03 False True True 2018-01-04 False False False 2018-01-05 False True False 7.6 ms ± 81.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 
en, ex = pd.Series.vbt.signals.generate_random_both(5, n=2, seed=42, index=index)
print(en)
print(ex)
en, ex = pd.DataFrame.vbt.signals.generate_random_both((5, 3), n=2, seed=42, index=index, columns=columns)
print(en)
print(ex)
en, ex = pd.DataFrame.vbt.signals.generate_random_both((5, 3), n=[0, 1, 2], seed=42, index=index, columns=columns)
print(en)
print(ex)
en, ex = pd.DataFrame.vbt.signals.generate_random_both((2, 3), n=2, seed=42, entry_wait=1, exit_wait=0)
print(en)
print(ex)
en, ex = pd.DataFrame.vbt.signals.generate_random_both((3, 3), n=2, seed=42, entry_wait=0, exit_wait=1)
print(en)
print(ex)
en, ex = pd.DataFrame.vbt.signals.generate_random_both((7, 3), n=2, seed=42, entry_wait=2, exit_wait=2)
print(en)
print(ex)

%timeit pd.DataFrame.vbt.signals.generate_random_both((1000, 1000), n=100)
%timeit pd.DataFrame.vbt.signals.generate_random_both((1000, 1000), n=100, exit_wait=0)
2018-01-01 True 2018-01-02 False 2018-01-03 True 2018-01-04 False 2018-01-05 False dtype: bool 2018-01-01 False 2018-01-02 True 2018-01-03 False 2018-01-04 False 2018-01-05 True dtype: bool a b c 2018-01-01 True True True 2018-01-02 False False False 2018-01-03 True True False 2018-01-04 False False True 2018-01-05 False False False a b c 2018-01-01 False False False 2018-01-02 True True True 2018-01-03 False False False 2018-01-04 False True False 2018-01-05 True False True a b c 2018-01-01 False False True 2018-01-02 False True False 2018-01-03 False False False 2018-01-04 False False True 2018-01-05 False False False a b c 2018-01-01 False False False 2018-01-02 False False True 2018-01-03 False False False 2018-01-04 False True False 2018-01-05 False False True 0 1 2 0 True True True 1 True True True 0 1 2 0 True True True 1 True True True 0 1 2 0 True True True 1 True True True 2 False False False 0 1 2 0 False False False 1 True True True 2 True True True 0 1 2 0 True True True 1 False False False 2 False False False 3 False False False 4 True True True 5 False False False 6 False False False 0 1 2 0 False False False 1 False False False 2 True True True 3 False False False 4 False False False 5 False False False 6 True True True 18.1 ms ± 108 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) 13.6 ms ± 66.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 
n = 10
a = np.full(n * 2, 0.)
for i in range(10000):
    en, ex = pd.Series.vbt.signals.generate_random_both(1000, n, entry_wait=2, exit_wait=2)
    _a = np.empty((n * 2,), dtype=np.int64)
    _a[0::2] = np.flatnonzero(en)
    _a[1::2] = np.flatnonzero(ex)
    a += _a
print(a)

b = np.full(n * 2, 0.)
for i in range(10000):
    b += np.sort(np.random.choice(1000, size=n * 2, replace=False))
print(b)
[ 454915. 931362. 1423666. 1894465. 2368430. 2859191. 3338920. 3817177. 4288740. 4759056. 5236445. 5708131. 6183311. 6675387. 7160407. 7633895. 8117773. 8596158. 9073611. 9541106.] [ 467525. 948228. 1415395. 1894228. 2371659. 2850128. 3329587. 3800772. 4277064. 4754194. 5233391. 5708592. 6180180. 6652306. 7127212. 7610069. 8087227. 8567550. 9043232. 9518372.] 
en, ex = pd.Series.vbt.signals.generate_random_both(
    5, entry_prob=0.5, exit_prob=1., seed=42, index=index)
print(en)
print(ex)
en, ex = pd.DataFrame.vbt.signals.generate_random_both(
    (5, 3), entry_prob=0.5, exit_prob=1., seed=42, index=index, columns=columns)
print(en)
print(ex)
en, ex = pd.DataFrame.vbt.signals.generate_random_both(
    (5, 3), entry_prob=[0., 0.5, 1.], exit_prob=[0., 0.5, 1.], seed=42, index=index, columns=columns)
print(en)
print(ex)
en, ex = pd.DataFrame.vbt.signals.generate_random_both(
    (5, 3), entry_prob=1., exit_prob=1., seed=42, index=index, columns=columns, exit_wait=0)
print(en)
print(ex)

%timeit pd.DataFrame.vbt.signals.generate_random_both(\
    (1000, 1000), entry_prob=1., exit_prob=1.)
2018-01-01 True 2018-01-02 False 2018-01-03 False 2018-01-04 False 2018-01-05 True dtype: bool 2018-01-01 False 2018-01-02 True 2018-01-03 False 2018-01-04 False 2018-01-05 False dtype: bool a b c 2018-01-01 True True True 2018-01-02 False False False 2018-01-03 False False False 2018-01-04 False False True 2018-01-05 True False False a b c 2018-01-01 False False False 2018-01-02 True True True 2018-01-03 False False False 2018-01-04 False False False 2018-01-05 False False True a b c 2018-01-01 False True True 2018-01-02 False False False 2018-01-03 False False True 2018-01-04 False False False 2018-01-05 False False True a b c 2018-01-01 False False False 2018-01-02 False True True 2018-01-03 False False False 2018-01-04 False False True 2018-01-05 False False False a b c 2018-01-01 True True True 2018-01-02 True True True 2018-01-03 True True True 2018-01-04 True True True 2018-01-05 True True True a b c 2018-01-01 True True True 2018-01-02 True True True 2018-01-03 True True True 2018-01-04 True True True 2018-01-05 True True True 44.6 ms ± 66.1 µs per loop (mean ± std. dev. of 7 runs, 10 loops each) 
e = pd.Series([True, False, False, False, False, False])
t = pd.Series([2, 3, 4, 3, 2, 1]).astype(np.float64)

print(e.vbt.signals.generate_stop_exits(t, -0.1))
print(e.vbt.signals.generate_stop_exits(t, -0.1, trailing=True))
print(e.vbt.signals.generate_stop_exits(t, -0.1, trailing=True, pick_first=False))
print(e.vbt.signals.generate_stop_exits(t.vbt.tile(3), [np.nan, -0.5, -1.], trailing=True, pick_first=False))
print(e.vbt.signals.generate_stop_exits(t, -0.1, trailing=True, exit_wait=3))

print(e.vbt.signals.generate_stop_exits(4 - t, 0.1))
print(e.vbt.signals.generate_stop_exits(4 - t, 0.1, trailing=True))
print(e.vbt.signals.generate_stop_exits(4 - t, 0.1, trailing=True, pick_first=False))
print(e.vbt.signals.generate_stop_exits((4 - t).vbt.tile(3), [np.nan, 0.5, 1.], trailing=True, pick_first=False))
print(e.vbt.signals.generate_stop_exits(4 - t, 0.1, trailing=True, exit_wait=3))

%timeit big_entries.vbt.signals.generate_stop_exits(big_ts, -0.1)
%timeit big_entries.vbt.signals.generate_stop_exits(big_ts, -0.1, trailing=True)
%timeit big_entries.vbt.signals.generate_stop_exits(big_ts, -0.1, trailing=True, pick_first=False)
0 False 1 False 2 False 3 False 4 False 5 True dtype: bool 0 False 1 False 2 False 3 True 4 False 5 False dtype: bool 0 False 1 False 2 False 3 True 4 True 5 True dtype: bool 0 1 2 0 False False False 1 False False False 2 False False False 3 False False False 4 False True False 5 False True False 0 False 1 False 2 False 3 False 4 True 5 False dtype: bool 0 False 1 False 2 False 3 False 4 False 5 True dtype: bool 0 False 1 False 2 False 3 True 4 False 5 False dtype: bool 0 False 1 False 2 False 3 True 4 True 5 True dtype: bool 0 1 2 0 False False False 1 False False False 2 False False False 3 False True True 4 False True True 5 False True True 0 False 1 False 2 False 3 False 4 True 5 False dtype: bool 11.1 ms ± 131 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 10.9 ms ± 71.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 32.8 ms ± 195 µs per loop (mean ± std. dev. of 7 runs, 10 loops each) 
e = pd.Series([True, True, True, True, True, True])
t = pd.Series([2, 3, 4, 3, 2, 1]).astype(np.float64)

en, ex = e.vbt.signals.generate_stop_exits(t, -0.1, trailing=True, chain=True)
print(en)
print(ex)
en, ex = e.vbt.signals.generate_stop_exits(t, -0.1, trailing=True, entry_wait=2, chain=True)
print(en)
print(ex)
en, ex = e.vbt.signals.generate_stop_exits(t, -0.1, trailing=True, exit_wait=2, chain=True)
print(en)
print(ex)

%timeit big_entries.vbt.signals.generate_stop_exits(big_ts, -0.1, chain=True)
%timeit big_entries.vbt.signals.generate_stop_exits(big_ts, -0.1, trailing=True, chain=True)
%timeit big_entries.vbt.signals.generate_stop_exits(big_ts, -0.1, trailing=True, pick_first=False, chain=True)
0 True 1 False 2 False 3 False 4 True 5 False dtype: bool 0 False 1 False 2 False 3 True 4 False 5 True dtype: bool 0 True 1 False 2 False 3 False 4 False 5 True dtype: bool 0 False 1 False 2 False 3 True 4 False 5 False dtype: bool 0 True 1 False 2 False 3 False 4 True 5 False dtype: bool 0 False 1 False 2 False 3 True 4 False 5 False dtype: bool 7.1 ms ± 137 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) 22.5 ms ± 79.1 µs per loop (mean ± std. dev. of 7 runs, 10 loops each) 7.89 ms ± 56.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 
def test_ohlc_stop_exits(**kwargs):
    out_dict = {}
    result = entries.vbt.signals.generate_ohlc_stop_exits(
        price['open'], price['high'], price['low'], price['close'],
        out_dict=out_dict, **kwargs
    )
    if isinstance(result, tuple):
        _, ex = result
    else:
        ex = result
    out_dict['stop_price'][~ex] = np.nan
    out_dict['stop_type'][~ex] = -1
    return result, out_dict['stop_price'], out_dict['stop_type']

ex, stop_price, stop_type = test_ohlc_stop_exits()
print(ex)
print(stop_price)
print(stop_type)

ex, stop_price, stop_type = test_ohlc_stop_exits(sl_stop=0.1)
print(ex)
print(stop_price)
print(stop_type)

ex, stop_price, stop_type = test_ohlc_stop_exits(sl_stop=0.1, sl_trail=True)
print(ex)
print(stop_price)
print(stop_type)

ex, stop_price, stop_type = test_ohlc_stop_exits(tp_stop=0.1)
print(ex)
print(stop_price)
print(stop_type)

ex, stop_price, stop_type = test_ohlc_stop_exits(sl_stop=0.1, sl_trail=True, tp_stop=0.1)
print(ex)
print(stop_price)
print(stop_type)

ex, stop_price, stop_type = test_ohlc_stop_exits(
    sl_stop=[np.nan, 0.5, 1.], sl_trail=True, tp_stop=[np.nan, 0.5, 1.])
print(ex)
print(stop_price)
print(stop_type)

ex, stop_price, stop_type = test_ohlc_stop_exits(sl_stop=0.1, sl_trail=True, tp_stop=0.1, exit_wait=0)
print(ex)
print(stop_price)
print(stop_type)

%timeit big_entries.vbt.signals.generate_ohlc_stop_exits(\
    big_ts, big_ts + 1, big_ts - 1, big_ts, sl_stop=0.1, sl_trail=True, tp_stop=0.1)
a b c 2018-01-01 False False False 2018-01-02 False False False 2018-01-03 False False False 2018-01-04 False False False 2018-01-05 False False False a b c 2018-01-01 NaN NaN NaN 2018-01-02 NaN NaN NaN 2018-01-03 NaN NaN NaN 2018-01-04 NaN NaN NaN 2018-01-05 NaN NaN NaN a b c 2018-01-01 -1 -1 -1 2018-01-02 -1 -1 -1 2018-01-03 -1 -1 -1 2018-01-04 -1 -1 -1 2018-01-05 -1 -1 -1 a b c 2018-01-01 False False False 2018-01-02 False False False 2018-01-03 False False False 2018-01-04 False True True 2018-01-05 True False False a b c 2018-01-01 NaN NaN NaN 2018-01-02 NaN NaN NaN 2018-01-03 NaN NaN NaN 2018-01-04 NaN 10.8 10.8 2018-01-05 9.0 NaN NaN a b c 2018-01-01 -1 -1 -1 2018-01-02 -1 -1 -1 2018-01-03 -1 -1 -1 2018-01-04 -1 0 0 2018-01-05 0 -1 -1 a b c 2018-01-01 False False False 2018-01-02 False False False 2018-01-03 False False False 2018-01-04 True True True 2018-01-05 False False False a b c 2018-01-01 NaN NaN NaN 2018-01-02 NaN NaN NaN 2018-01-03 NaN NaN NaN 2018-01-04 11.7 10.8 10.8 2018-01-05 NaN NaN NaN a b c 2018-01-01 -1 -1 -1 2018-01-02 -1 -1 -1 2018-01-03 -1 -1 -1 2018-01-04 1 1 1 2018-01-05 -1 -1 -1 a b c 2018-01-01 False False False 2018-01-02 True True False 2018-01-03 False False False 2018-01-04 False False False 2018-01-05 False False False a b c 2018-01-01 NaN NaN NaN 2018-01-02 11.0 11.0 NaN 2018-01-03 NaN NaN NaN 2018-01-04 NaN NaN NaN 2018-01-05 NaN NaN NaN a b c 2018-01-01 -1 -1 -1 2018-01-02 2 2 -1 2018-01-03 -1 -1 -1 2018-01-04 -1 -1 -1 2018-01-05 -1 -1 -1 a b c 2018-01-01 False False False 2018-01-02 True True False 2018-01-03 False False False 2018-01-04 False True True 2018-01-05 False False False a b c 2018-01-01 NaN NaN NaN 2018-01-02 11.0 11.0 NaN 2018-01-03 NaN NaN NaN 2018-01-04 NaN 10.8 10.8 2018-01-05 NaN NaN NaN a b c 2018-01-01 -1 -1 -1 2018-01-02 2 2 -1 2018-01-03 -1 -1 -1 2018-01-04 -1 1 1 2018-01-05 -1 -1 -1 a b c 2018-01-01 False False False 2018-01-02 False False False 2018-01-03 False False False 2018-01-04 False False False 2018-01-05 False False False a b c 2018-01-01 NaN NaN NaN 2018-01-02 NaN NaN NaN 2018-01-03 NaN NaN NaN 2018-01-04 NaN NaN NaN 2018-01-05 NaN NaN NaN a b c 2018-01-01 -1 -1 -1 2018-01-02 -1 -1 -1 2018-01-03 -1 -1 -1 2018-01-04 -1 -1 -1 2018-01-05 -1 -1 -1 a b c 2018-01-01 True True True 2018-01-02 False False False 2018-01-03 False False False 2018-01-04 False True True 2018-01-05 False True False a b c 2018-01-01 9.0 9.0 9.0 2018-01-02 NaN NaN NaN 2018-01-03 NaN NaN NaN 2018-01-04 NaN 11.7 11.7 2018-01-05 NaN 9.0 NaN a b c 2018-01-01 1 1 1 2018-01-02 -1 -1 -1 2018-01-03 -1 -1 -1 2018-01-04 -1 1 1 2018-01-05 -1 1 -1 20.3 ms ± 853 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) 
(en, ex), stop_price, stop_type = test_ohlc_stop_exits(sl_stop=0.1, sl_trail=True, tp_stop=0.1, chain=True)
print(en)
print(ex)
print(stop_price)
print(stop_type)

%timeit big_entries.vbt.signals.generate_ohlc_stop_exits(\
    big_ts, big_ts + 1, big_ts - 1, big_ts, sl_stop=0.1, sl_trail=True, tp_stop=0.1, chain=True)
a b c 2018-01-01 True True True 2018-01-02 False False False 2018-01-03 False True True 2018-01-04 False False False 2018-01-05 False True False a b c 2018-01-01 False False False 2018-01-02 True True True 2018-01-03 False False False 2018-01-04 False True True 2018-01-05 False False False a b c 2018-01-01 NaN NaN NaN 2018-01-02 11.0 11.0 11.0 2018-01-03 NaN NaN NaN 2018-01-04 NaN 10.8 10.8 2018-01-05 NaN NaN NaN a b c 2018-01-01 -1 -1 -1 2018-01-02 2 2 2 2018-01-03 -1 -1 -1 2018-01-04 -1 1 1 2018-01-05 -1 -1 -1 33.5 ms ± 800 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) 
distance_map_nb = njit(lambda prev_i, next_i, col: next_i - prev_i)
avg_reduce_nb = njit(lambda col, a: np.nanmean(a))

print(entries.vbt.signals.map_reduce_between(
    range_map_func_nb=distance_map_nb, reduce_func_nb=avg_reduce_nb))

%timeit big_entries.vbt.signals.map_reduce_between(\
    range_map_func_nb=distance_map_nb, reduce_func_nb=avg_reduce_nb)
a NaN b 2.0 c 1.0 Name: map_reduce_between, dtype: float64 1.79 ms ± 14.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) 
print(entries.vbt.signals.map_reduce_between(
    other=entries.vbt.signals.fshift(1), 
    range_map_func_nb=distance_map_nb, 
    reduce_func_nb=avg_reduce_nb))

%timeit big_entries.vbt.signals.map_reduce_between(\
    other=big_entries.vbt.signals.fshift(1),\
    range_map_func_nb=distance_map_nb,\
    reduce_func_nb=avg_reduce_nb)
a 1.000000 b 1.000000 c 0.333333 Name: map_reduce_between_two, dtype: float64 43.9 ms ± 421 µs per loop (mean ± std. dev. of 7 runs, 10 loops each) 
print(entries.vbt.signals.map_reduce_partitions(
    range_map_func_nb=distance_map_nb, reduce_func_nb=avg_reduce_nb))

%timeit big_entries.vbt.signals.map_reduce_partitions(\
    range_map_func_nb=distance_map_nb, reduce_func_nb=avg_reduce_nb)
a 1.0 b 1.0 c 3.0 Name: map_reduce_partitions, dtype: float64 1.31 ms ± 14.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) 
print(entries['a'].vbt.signals.total())
print(entries.vbt.signals.total())

%timeit big_entries.vbt.signals.total()
1 a 1 b 3 c 3 Name: total, dtype: int64 693 µs ± 527 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each) 
print(entries['a'].vbt.signals.avg_distance())
print(entries.vbt.signals.avg_distance())

%timeit big_entries.vbt.signals.avg_distance()
nan a NaN b 2.0 c 1.0 Name: avg_distance, dtype: float64 1.8 ms ± 22.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) 
print(entries['a'].vbt.signals.avg_distance(to=entries['a'].vbt.signals.fshift(1)))
print(entries.vbt.signals.avg_distance(to=entries.vbt.signals.fshift(1)))

%timeit big_entries.vbt.signals.avg_distance(to=big_entries.vbt.signals.fshift(1))
1.0 a 1.000000 b 1.000000 c 0.333333 Name: avg_distance, dtype: float64 42.8 ms ± 72.2 µs per loop (mean ± std. dev. of 7 runs, 10 loops each) 
print(entries['a'].vbt.signals.pos_rank())
print(entries.vbt.signals.pos_rank())

print(entries['a'].vbt.signals.pos_rank(after_false=True))
print(entries.vbt.signals.pos_rank(after_false=True))

print(entries['a'].vbt.signals.pos_rank(allow_gaps=True))
print(entries.vbt.signals.pos_rank(allow_gaps=True))

print(entries['a'].vbt.signals.pos_rank(allow_gaps=True, reset_by=~entries['a']))
print(entries.vbt.signals.pos_rank(allow_gaps=True, reset_by=~entries))

%timeit big_entries.vbt.signals.pos_rank()
2018-01-01 0 2018-01-02 -1 2018-01-03 -1 2018-01-04 -1 2018-01-05 -1 Name: a, dtype: int64 a b c 2018-01-01 0 0 0 2018-01-02 -1 -1 1 2018-01-03 -1 0 2 2018-01-04 -1 -1 -1 2018-01-05 -1 0 -1 2018-01-01 -1 2018-01-02 -1 2018-01-03 -1 2018-01-04 -1 2018-01-05 -1 Name: a, dtype: int64 a b c 2018-01-01 -1 -1 -1 2018-01-02 -1 -1 -1 2018-01-03 -1 0 -1 2018-01-04 -1 -1 -1 2018-01-05 -1 0 -1 2018-01-01 0 2018-01-02 -1 2018-01-03 -1 2018-01-04 -1 2018-01-05 -1 Name: a, dtype: int64 a b c 2018-01-01 0 0 0 2018-01-02 -1 -1 1 2018-01-03 -1 1 2 2018-01-04 -1 -1 -1 2018-01-05 -1 2 -1 2018-01-01 0 2018-01-02 -1 2018-01-03 -1 2018-01-04 -1 2018-01-05 -1 Name: a, dtype: int64 a b c 2018-01-01 0 0 0 2018-01-02 -1 -1 1 2018-01-03 -1 0 2 2018-01-04 -1 -1 -1 2018-01-05 -1 0 -1 2.9 ms ± 56.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 
print(entries['a'].vbt.signals.partition_pos_rank())
print(entries.vbt.signals.partition_pos_rank())

print(entries['a'].vbt.signals.partition_pos_rank(after_false=True))
print(entries.vbt.signals.partition_pos_rank(after_false=True))

print(entries['a'].vbt.signals.partition_pos_rank(reset_by=~entries['a']))
print(entries.vbt.signals.partition_pos_rank(reset_by=~entries))

%timeit big_entries.vbt.signals.partition_pos_rank()
2018-01-01 0 2018-01-02 -1 2018-01-03 -1 2018-01-04 -1 2018-01-05 -1 Name: a, dtype: int64 a b c 2018-01-01 0 0 0 2018-01-02 -1 -1 0 2018-01-03 -1 1 0 2018-01-04 -1 -1 -1 2018-01-05 -1 2 -1 2018-01-01 -1 2018-01-02 -1 2018-01-03 -1 2018-01-04 -1 2018-01-05 -1 Name: a, dtype: int64 a b c 2018-01-01 -1 -1 -1 2018-01-02 -1 -1 -1 2018-01-03 -1 0 -1 2018-01-04 -1 -1 -1 2018-01-05 -1 1 -1 2018-01-01 0 2018-01-02 -1 2018-01-03 -1 2018-01-04 -1 2018-01-05 -1 Name: a, dtype: int64 a b c 2018-01-01 0 0 0 2018-01-02 -1 -1 0 2018-01-03 -1 0 0 2018-01-04 -1 -1 -1 2018-01-05 -1 0 -1 2.83 ms ± 37.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 
print(entries.vbt.signals.first())

%timeit big_entries.vbt.signals.first()
a b c 2018-01-01 True True True 2018-01-02 False False False 2018-01-03 False True False 2018-01-04 False False False 2018-01-05 False True False 3.3 ms ± 81.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 
print(entries & entries)
%timeit big_entries & big_entries

print(entries.vbt.signals.AND(entries))
%timeit big_entries.vbt.signals.AND(big_entries) # a bit slower but does smart broadcasting
a b c 2018-01-01 True True True 2018-01-02 False False True 2018-01-03 False True True 2018-01-04 False False False 2018-01-05 False True False 160 µs ± 3.78 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each) a b c 2018-01-01 True True True 2018-01-02 False False True 2018-01-03 False True True 2018-01-04 False False False 2018-01-05 False True False 1.33 ms ± 182 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) 
print(entries.vbt.signals.OR([ts > 1, ts > 2, ts > 3])) # you can pass multiple arguments
print(entries.vbt.signals.OR([ts > 1, ts > 2, ts > 3], concat=True, keys=['>1', '>2', '>3']))
a b c 2018-01-01 True True True 2018-01-02 True True True 2018-01-03 True True True 2018-01-04 True True True 2018-01-05 False True False >1 >2 >3 a b c a b c a b c 2018-01-01 True True True True True True True True True 2018-01-02 True True True False False True False False True 2018-01-03 True True True True True True False True True 2018-01-04 True True True False False False False False False 2018-01-05 False True False False True False False True False 
print(entries['a'].vbt.signals.stats())
%timeit big_entries[0].vbt.signals.stats(silence_warnings=True)

print(entries.vbt.signals.stats(column='a'))
%timeit big_entries.vbt.signals.stats(column=0, silence_warnings=True)

print(entries.vbt.signals.stats())
%timeit big_entries.vbt.signals.stats(silence_warnings=True)
                                      
print(entries.vbt.signals.stats(settings=dict(other=~entries)))
%timeit big_entries.vbt.signals.stats(settings=dict(other=~big_entries), silence_warnings=True)
Start 2018-01-01 00:00:00 End 2018-01-05 00:00:00 Period 5 days 00:00:00 Total 1 Rate [%] 20.0 First Index 2018-01-01 00:00:00 Last Index 2018-01-01 00:00:00 Norm Avg Index [-1, 1] -1.0 Distance: Min NaT Distance: Max NaT Distance: Mean NaT Distance: Std NaT Total Partitions 1 Partition Rate [%] 100.0 Partition Length: Min 1 days 00:00:00 Partition Length: Max 1 days 00:00:00 Partition Length: Mean 1 days 00:00:00 Partition Length: Std NaT Partition Distance: Min NaT Partition Distance: Max NaT Partition Distance: Mean NaT Partition Distance: Std NaT Name: a, dtype: object 9.75 ms ± 142 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) Start 2018-01-01 00:00:00 End 2018-01-05 00:00:00 Period 5 days 00:00:00 Total 1 Rate [%] 20.0 First Index 2018-01-01 00:00:00 Last Index 2018-01-01 00:00:00 Norm Avg Index [-1, 1] -1.0 Distance: Min NaT Distance: Max NaT Distance: Mean NaT Distance: Std NaT Total Partitions 1 Partition Rate [%] 100.0 Partition Length: Min 1 days 00:00:00 Partition Length: Max 1 days 00:00:00 Partition Length: Mean 1 days 00:00:00 Partition Length: Std NaT Partition Distance: Min NaT Partition Distance: Max NaT Partition Distance: Mean NaT Partition Distance: Std NaT Name: a, dtype: object 30.5 ms ± 982 µs per loop (mean ± std. dev. of 7 runs, 10 loops each) Start 2018-01-01 00:00:00 End 2018-01-05 00:00:00 Period 5 days 00:00:00 Total 2.333333 Rate [%] 46.666667 First Index 2018-01-01 00:00:00 Last Index 2018-01-03 00:00:00 Norm Avg Index [-1, 1] -0.5 Distance: Min 1 days 12:00:00 Distance: Max 1 days 12:00:00 Distance: Mean 1 days 12:00:00 Distance: Std 0 days 00:00:00 Total Partitions 1.666667 Partition Rate [%] 77.777778 Partition Length: Min 1 days 16:00:00 Partition Length: Max 1 days 16:00:00 Partition Length: Mean 1 days 16:00:00 Partition Length: Std 0 days 00:00:00 Partition Distance: Min 2 days 00:00:00 Partition Distance: Max 2 days 00:00:00 Partition Distance: Mean 2 days 00:00:00 Partition Distance: Std 0 days 00:00:00 Name: agg_func_mean, dtype: object
/Users/olegpolakow/miniconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: UserWarning: Object has multiple columns. Aggregating using <function mean at 0x7fe8580767b8>. Pass column to select a single column/group. import sys
30.4 ms ± 120 µs per loop (mean ± std. dev. of 7 runs, 10 loops each) Start 2018-01-01 00:00:00 End 2018-01-05 00:00:00 Period 5 days 00:00:00 Total 2.333333 Rate [%] 46.666667 Total Overlapping 0.0 Overlapping Rate [%] 0.0 First Index 2018-01-01 00:00:00 Last Index 2018-01-03 00:00:00 Norm Avg Index [-1, 1] -0.5 Distance -> Other: Min 1 days 00:00:00 Distance -> Other: Max 1 days 16:00:00 Distance -> Other: Mean 1 days 08:00:00 Distance -> Other: Std 0 days 12:00:00 Total Partitions 1.666667 Partition Rate [%] 77.777778 Partition Length: Min 1 days 16:00:00 Partition Length: Max 1 days 16:00:00 Partition Length: Mean 1 days 16:00:00 Partition Length: Std 0 days 00:00:00 Partition Distance: Min 2 days 00:00:00 Partition Distance: Max 2 days 00:00:00 Partition Distance: Mean 2 days 00:00:00 Partition Distance: Std 0 days 00:00:00 Name: agg_func_mean, dtype: object
/Users/olegpolakow/miniconda3/lib/python3.7/site-packages/ipykernel_launcher.py:10: UserWarning: Object has multiple columns. Aggregating using <function mean at 0x7fe8580767b8>. Pass column to select a single column/group. # Remove the CWD from sys.path while we load stuff.
160 ms ± 1.69 ms per loop (mean ± std. dev. of 7 runs, 10 loops each) 
entries.vbt.signals.plot().show_svg()
Image in a Jupyter notebook
entries['a'].vbt.signals.plot().show_svg()
Image in a Jupyter notebook
entries['a'].vbt.signals.plot_as_markers(ts).show_svg()
Image in a Jupyter notebook
entries['a'].vbt.signals.plot_as_entry_markers(ts).show_svg()
Image in a Jupyter notebook
entries['a'].vbt.signals.plot_as_exit_markers(ts).show_svg()
Image in a Jupyter notebook

factory

@njit
def choice_nb(from_i, to_i, col, ts, in_out, n, arg, temp_idx_arr, kw):
    in_out[from_i, col] = ts[from_i, col] * n + arg + kw
    temp_idx_arr[0] = from_i
    return temp_idx_arr[:1]

MySignals = vbt.SignalFactory(
    input_names=['ts1', 'ts2'],
    in_output_names=['in_out1', 'in_out2'],
    param_names=['n1', 'n2']
).from_choice_func(
    entry_choice_func=choice_nb,
    entry_settings=dict(
        pass_inputs=['ts1'],
        pass_in_outputs=['in_out1'],
        pass_params=['n1'],
        pass_kwargs=['temp_idx_arr1', ('kw1', 1000)]
    ),
    exit_choice_func=choice_nb,
    exit_settings=dict(
        pass_inputs=['ts2'],
        pass_in_outputs=['in_out2'],
        pass_params=['n2'],
        pass_kwargs=['temp_idx_arr2', ('kw2', 1000)]
    ),
    in_output_settings=dict(
        in_out1=dict(
            dtype=np.float64
        ),
        in_out2=dict(
            dtype=np.float64
        )
    ),
    in_out1=np.nan,
    in_out2=np.nan,
    var_args=True,
    require_input_shape=False
)
my_sig = MySignals.run(np.arange(5), np.arange(5), [0, 1], [1, 0], entry_args=(100,), exit_args=(100,))
print(my_sig.entries)
print(my_sig.exits)
print(my_sig.in_out1)
print(my_sig.in_out2)
my_sig[(0, 1)].plot().show_svg()
custom_n1 0 1 custom_n2 1 0 0 True True 1 False False 2 True True 3 False False 4 True True custom_n1 0 1 custom_n2 1 0 0 False False 1 True True 2 False False 3 True True 4 False False custom_n1 0 1 custom_n2 1 0 0 1100.0 1100.0 1 NaN NaN 2 1100.0 1102.0 3 NaN NaN 4 1100.0 1104.0 custom_n1 0 1 custom_n2 1 0 0 NaN NaN 1 1101.0 1100.0 2 NaN NaN 3 1103.0 1100.0 4 NaN NaN
Image in a Jupyter notebook
my_sig = MySignals.run(
    np.arange(7), np.arange(7), [0, 1], [1, 0], 
    entry_args=(100,), exit_args=(100,), 
    entry_kwargs=dict(wait=2), exit_kwargs=dict(wait=2)
)
print(my_sig.entries)
print(my_sig.exits)
print(my_sig.in_out1)
print(my_sig.in_out2)
custom_n1 0 1 custom_n2 1 0 0 True True 1 False False 2 False False 3 False False 4 True True 5 False False 6 False False custom_n1 0 1 custom_n2 1 0 0 False False 1 False False 2 True True 3 False False 4 False False 5 False False 6 True True custom_n1 0 1 custom_n2 1 0 0 1100.0 1100.0 1 NaN NaN 2 NaN NaN 3 NaN NaN 4 1100.0 1104.0 5 NaN NaN 6 NaN NaN custom_n1 0 1 custom_n2 1 0 0 NaN NaN 1 NaN NaN 2 1102.0 1100.0 3 NaN NaN 4 NaN NaN 5 NaN NaN 6 1106.0 1100.0 
MySignals = vbt.SignalFactory(
    input_names=['ts2'],
    in_output_names=['in_out2'],
    param_names=['n2'],
    mode='exits'
).from_choice_func(
    exit_choice_func=choice_nb,
    exit_settings=dict(
        pass_inputs=['ts2'],
        pass_in_outputs=['in_out2'],
        pass_params=['n2'],
        pass_kwargs=['temp_idx_arr2', ('kw2', 1000)]
    ),
    in_output_settings=dict(
        in_out2=dict(
            dtype=np.float64
        )
    ),
    in_out2=np.nan,
    var_args=True
)
e = np.array([True, False, True, False, True])
my_sig = MySignals.run(e, np.arange(5), [1, 0], 100)
print(my_sig.entries)
print(my_sig.exits)
print(my_sig.in_out2)
my_sig[0].plot().show_svg()
custom_n2 1 0 0 True True 1 False False 2 True True 3 False False 4 True True custom_n2 1 0 0 False False 1 True True 2 False False 3 True True 4 False False custom_n2 1 0 0 NaN NaN 1 1101.0 1100.0 2 NaN NaN 3 1103.0 1100.0 4 NaN NaN
Image in a Jupyter notebook
e = np.array([True, False, False, True, False, False])
my_sig = MySignals.run(e, np.arange(6), [1, 0], 100, wait=2)
print(my_sig.entries)
print(my_sig.exits)
print(my_sig.in_out2)
custom_n2 1 0 0 True True 1 False False 2 False False 3 True True 4 False False 5 False False custom_n2 1 0 0 False False 1 False False 2 True True 3 False False 4 False False 5 True True custom_n2 1 0 0 NaN NaN 1 NaN NaN 2 1102.0 1100.0 3 NaN NaN 4 NaN NaN 5 1105.0 1100.0 
MySignals = vbt.SignalFactory(
    input_names=['ts2'],
    in_output_names=['in_out2'],
    param_names=['n2'],
    mode='chain'
).from_choice_func(
    exit_choice_func=choice_nb,
    exit_settings=dict(
        pass_inputs=['ts2'],
        pass_in_outputs=['in_out2'],
        pass_params=['n2'],
        pass_kwargs=['temp_idx_arr2', ('kw2', 1000)]
    ),
    in_output_settings=dict(
        in_out2=dict(
            dtype=np.float64
        )
    ),
    in_out2=np.nan, 
    var_args=True
)
e = np.array([True, True, True, True, True])
my_sig = MySignals.run(e, np.arange(5), [1, 0], 100)
print(my_sig.entries)
print(my_sig.new_entries)
print(my_sig.exits)
print(my_sig.in_out2)
my_sig[0].plot().show_svg()
custom_n2 1 0 0 True True 1 True True 2 True True 3 True True 4 True True custom_n2 1 0 0 True True 1 False False 2 True True 3 False False 4 True True custom_n2 1 0 0 False False 1 True True 2 False False 3 True True 4 False False custom_n2 1 0 0 NaN NaN 1 1101.0 1100.0 2 NaN NaN 3 1103.0 1100.0 4 NaN NaN
Image in a Jupyter notebook
e = np.array([True, True, True, True, True, True])
my_sig = MySignals.run(e, np.arange(6), [1, 0], 100, wait=2)
print(my_sig.entries)
print(my_sig.new_entries)
print(my_sig.exits)
print(my_sig.in_out2)
custom_n2 1 0 0 True True 1 True True 2 True True 3 True True 4 True True 5 True True custom_n2 1 0 0 True True 1 False False 2 False False 3 True True 4 False False 5 False False custom_n2 1 0 0 False False 1 False False 2 True True 3 False False 4 False False 5 True True custom_n2 1 0 0 NaN NaN 1 NaN NaN 2 1102.0 1100.0 3 NaN NaN 4 NaN NaN 5 1105.0 1100.0

basic

RANDNX

randnx = vbt.RANDNX.run(n=1, input_shape=(6,), seed=42)

print(randnx.entries)
print(randnx.exits)
0 True 1 False 2 False 3 False 4 False 5 False Name: 1, dtype: bool 0 False 1 True 2 False 3 False 4 False 5 False Name: 1, dtype: bool 
randnx = vbt.RANDNX.run(n=[1, 2, 3], input_shape=(6,), seed=42)

print(randnx.entries)
print(randnx.exits)
randnx_n 1 2 3 0 True True True 1 False False False 2 False True True 3 False False False 4 False False True 5 False False False randnx_n 1 2 3 0 False False False 1 True True True 2 False False False 3 False True True 4 False False False 5 False False True 
randnx = vbt.RANDNX.run(n=[np.array([1, 2]), np.array([3, 4])], input_shape=(8, 2), seed=42)

print(randnx.entries)
print(randnx.exits)
randnx_n 1 2 3 4 0 1 0 1 0 False True True True 1 True False False False 2 False False False True 3 False False True False 4 False True False True 5 False False True False 6 False False False True 7 False False False False randnx_n 1 2 3 4 0 1 0 1 0 False False False False 1 False False True True 2 False False False False 3 False True False True 4 False False True False 5 True False False True 6 False False True False 7 False True False True 
%timeit vbt.RANDNX.run(n=100, input_shape=(1000, 1000), seed=42)
%timeit vbt.RANDNX.run(n=np.full(10, 100).tolist(), input_shape=(1000, 1000), seed=42)
20.5 ms ± 485 µs per loop (mean ± std. dev. of 7 runs, 10 loops each) 198 ms ± 1.35 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

RPROBNX

rprobnx = vbt.RPROBNX.run(entry_prob=1., exit_prob=1., input_shape=(5,), seed=42)

print(rprobnx.entries)
print(rprobnx.exits)
0 True 1 False 2 True 3 False 4 True Name: (1.0, 1.0), dtype: bool 0 False 1 True 2 False 3 True 4 False Name: (1.0, 1.0), dtype: bool 
rprobnx = vbt.RPROBNX.run(
    entry_prob=np.asarray([1., 0., 1., 0., 1.]), 
    exit_prob=np.asarray([0., 1., 0., 1., 0.]), 
    input_shape=(5,), seed=42)

print(rprobnx.entries)
print(rprobnx.exits)
0 True 1 False 2 True 3 False 4 True Name: (array_0, array_0), dtype: bool 0 False 1 True 2 False 3 True 4 False Name: (array_0, array_0), dtype: bool 
rprobnx = vbt.RPROBNX.run(entry_prob=[0.5, 1.], exit_prob=[1., 0.5], input_shape=(5,), seed=42)

print(rprobnx.entries)
print(rprobnx.exits)
rprobnx_entry_prob 0.5 1.0 rprobnx_exit_prob 1.0 0.5 0 True True 1 False False 2 False True 3 False False 4 True False rprobnx_entry_prob 0.5 1.0 rprobnx_exit_prob 1.0 0.5 0 False False 1 True True 2 False False 3 False False 4 False False 
%timeit vbt.RPROBNX.run(entry_prob=1., exit_prob=1., input_shape=(1000, 1000), seed=42)
%timeit vbt.RPROBNX.run(\
    entry_prob=np.full(10, 1.).tolist(), exit_prob=np.full(10, 1.).tolist(), \
    input_shape=(1000, 1000), seed=42)
51 ms ± 390 µs per loop (mean ± std. dev. of 7 runs, 10 loops each) 503 ms ± 3.47 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

RPROBX

rprobx = vbt.RPROBX.run(entries, prob=[0., 0.5, 1.], seed=42)

print(rprobx.exits)
rprobx_prob 0.0 0.5 1.0 a b c a b c a b c 2018-01-01 False False False False False False False False False 2018-01-02 False False False False False False True True False 2018-01-03 False False False False False False False False False 2018-01-04 False False False True False True False True True 2018-01-05 False False False False False False False False False 
%timeit vbt.RPROBX.run(big_entries, prob=1., seed=42)
%timeit vbt.RPROBX.run(big_entries, prob=np.full(10, 1.).tolist(), seed=42)
8.19 ms ± 211 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) 71.8 ms ± 1.01 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

RPROBCX

rprobcx = vbt.RPROBCX.run(entries, prob=[0., 0.5, 1.], seed=42)

print(rprobcx.new_entries)
print(rprobcx.exits)
rprobcx_prob 0.0 0.5 1.0 a b c a b c a b c 2018-01-01 True True True True True True True True True 2018-01-02 False False False False False False False False False 2018-01-03 False False False False True True False True True 2018-01-04 False False False False False False False False False 2018-01-05 False False False False True False False True False rprobcx_prob 0.0 0.5 1.0 a b c a b c a b c 2018-01-01 False False False False False False False False False 2018-01-02 False False False False True True True True True 2018-01-03 False False False True False False False False False 2018-01-04 False False False False True False False True True 2018-01-05 False False False False False True False False False 
%timeit vbt.RPROBCX.run(big_entries, prob=1., seed=42)
%timeit vbt.RPROBCX.run(big_entries, prob=np.full(10, 1.).tolist(), seed=42)
20.8 ms ± 167 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) 202 ms ± 2.47 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

STX

stx = vbt.STX.run(entries, ts, 0.1)

print(stx.exits)
stx_stop 0.1 a b c 2018-01-01 False False False 2018-01-02 True True False 2018-01-03 False False False 2018-01-04 False False False 2018-01-05 False False False 
stx = vbt.STX.run(entries, ts, np.asarray([0.1, 0.1, -0.1, -0.1, -0.1])[:, None])

print(stx.exits)
stx_stop array_0 a b c 2018-01-01 False False False 2018-01-02 True True False 2018-01-03 False False False 2018-01-04 False True True 2018-01-05 False False False 
stx = vbt.STX.run(entries, ts, [0.1, 0.1, -0.1, -0.1], trailing=[False, True, False, True])

print(stx.exits)
stx_stop 0.1 -0.1 \ stx_trailing False True False a b c a b c a b c 2018-01-01 False False False False False False False False False 2018-01-02 True True False True True False False False False 2018-01-03 False False False False False False False False False 2018-01-04 False False False False False False False True True 2018-01-05 False False False False False False False False False stx_stop stx_trailing True a b c 2018-01-01 False False False 2018-01-02 False False False 2018-01-03 False False False 2018-01-04 True True True 2018-01-05 False False False 
%timeit vbt.STX.run(big_entries, big_ts, 0.1)
%timeit vbt.STX.run(big_entries, big_ts, np.full(10, 0.1).tolist())
14 ms ± 177 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) 119 ms ± 1.75 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

STCX

stcx = vbt.STCX.run(entries, ts, [0.1, 0.1, -0.1, -0.1], trailing=[False, True, False, True])

print(stcx.new_entries)
print(stcx.exits)
stcx_stop 0.1 -0.1 \ stcx_trailing False True False a b c a b c a b c 2018-01-01 True True True True True True True True True 2018-01-02 False False False False False False False False False 2018-01-03 False True True False True True False False False 2018-01-04 False False False False False False False False False 2018-01-05 False False False False False False False False False stcx_stop stcx_trailing True a b c 2018-01-01 True True True 2018-01-02 False False False 2018-01-03 False False False 2018-01-04 False False False 2018-01-05 False True False stcx_stop 0.1 -0.1 \ stcx_trailing False True False a b c a b c a b c 2018-01-01 False False False False False False False False False 2018-01-02 True True True True True True False False False 2018-01-03 False False False False False False False False False 2018-01-04 False False False False False False False False False 2018-01-05 False False False False False False False False False stcx_stop stcx_trailing True a b c 2018-01-01 False False False 2018-01-02 False False False 2018-01-03 False False False 2018-01-04 True True True 2018-01-05 False False False 
%timeit vbt.STCX.run(big_entries, big_ts, 0.1)
%timeit vbt.STCX.run(big_entries, big_ts, np.full(10, 0.1).tolist())
9.44 ms ± 92.1 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) 77 ms ± 1.08 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

OHLCSTX

ohlcstx = vbt.OHLCSTX.run(
    entries, price['open'], price['high'], price['low'], price['close'], 
    sl_stop=0.1
)

print(ohlcstx.exits)
print(ohlcstx.stop_price)
print(ohlcstx.stop_type_readable)
ohlcstx[(0.1, 'b')].plot().show_svg()
ohlcstx_sl_stop 0.1 a b c 2018-01-01 False False False 2018-01-02 False False False 2018-01-03 False False False 2018-01-04 False True True 2018-01-05 True False False ohlcstx_sl_stop 0.1 a b c 2018-01-01 NaN NaN NaN 2018-01-02 NaN NaN NaN 2018-01-03 NaN NaN NaN 2018-01-04 NaN 10.8 10.8 2018-01-05 9.0 NaN NaN ohlcstx_sl_stop 0.1 a b c 2018-01-01 None None None 2018-01-02 None None None 2018-01-03 None None None 2018-01-04 None StopLoss StopLoss 2018-01-05 StopLoss None None
Image in a Jupyter notebook
ohlcstx = vbt.OHLCSTX.run(
    entries, price['open'], price['high'], price['low'], price['close'], 
    sl_stop=[0.1, 0., 0.], ts_stop=[0., 0.1, 0.], tp_stop=[0., 0., 0.1]
)

print(ohlcstx.exits)
print(ohlcstx.stop_price)
print(ohlcstx.stop_type_readable)
ohlcstx_sl_stop 0.1 0.0 ohlcstx_tp_stop 0.0 0.0 0.1 a b c a b c a b c 2018-01-01 False False False False False False False False False 2018-01-02 True True False True True False True True False 2018-01-03 False False False False False False False False False 2018-01-04 False True True False True True False True True 2018-01-05 False False False False False False False False False ohlcstx_sl_stop 0.1 0.0 ohlcstx_tp_stop 0.0 0.0 0.1 a b c a b c a b c 2018-01-01 NaN NaN NaN NaN NaN NaN NaN NaN NaN 2018-01-02 10.0 10.0 NaN 10.0 10.0 NaN 10.0 10.0 NaN 2018-01-03 NaN NaN NaN NaN NaN NaN NaN NaN NaN 2018-01-04 NaN 10.8 10.8 NaN 12.0 12.0 NaN 12.0 12.0 2018-01-05 NaN NaN NaN NaN NaN NaN NaN NaN NaN ohlcstx_sl_stop 0.1 0.0 \ ohlcstx_tp_stop 0.0 0.0 a b c a b 2018-01-01 None None None None None 2018-01-02 TakeProfit TakeProfit None StopLoss StopLoss 2018-01-03 None None None None None 2018-01-04 None StopLoss StopLoss None StopLoss 2018-01-05 None None None None None ohlcstx_sl_stop ohlcstx_tp_stop 0.1 c a b c 2018-01-01 None None None None 2018-01-02 None StopLoss StopLoss None 2018-01-03 None None None None 2018-01-04 StopLoss None StopLoss StopLoss 2018-01-05 None None None None 
%timeit vbt.OHLCSTX.run(\
    big_entries, big_ts, big_ts + 1, big_ts - 1, big_ts,\
    sl_stop=0.1, ts_stop=0.1, tp_stop=0.1)
%timeit vbt.OHLCSTX.run(\
    big_entries, big_ts, big_ts + 1, big_ts - 1, big_ts,\
    sl_stop=np.full(10, 0.1).tolist(), ts_stop=np.full(10, 0.1).tolist(), tp_stop=np.full(10, 0.1).tolist())
28.1 ms ± 605 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) 226 ms ± 7.07 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

OHLCSTCX

ohlcstcx = vbt.OHLCSTCX.run(
    entries, price['open'], price['high'], price['low'], price['close'], 
    sl_stop=0.1
)

print(ohlcstcx.new_entries)
print(ohlcstcx.exits)
print(ohlcstcx.stop_price)
print(ohlcstcx.stop_type_readable)
ohlcstcx[(0.1, 'b')].plot().show_svg()
ohlcstcx_sl_stop 0.1 a b c 2018-01-01 True True True 2018-01-02 False False False 2018-01-03 False False False 2018-01-04 False False False 2018-01-05 False False False ohlcstcx_sl_stop 0.1 a b c 2018-01-01 False False False 2018-01-02 False False False 2018-01-03 False False False 2018-01-04 False False False 2018-01-05 True True True ohlcstcx_sl_stop 0.1 a b c 2018-01-01 NaN NaN NaN 2018-01-02 NaN NaN NaN 2018-01-03 NaN NaN NaN 2018-01-04 NaN NaN NaN 2018-01-05 9.0 9.0 9.0 ohlcstcx_sl_stop 0.1 a b c 2018-01-01 None None None 2018-01-02 None None None 2018-01-03 None None None 2018-01-04 None None None 2018-01-05 StopLoss StopLoss StopLoss
Image in a Jupyter notebook
%timeit vbt.OHLCSTCX.run(\
    big_entries, big_ts, big_ts + 1, big_ts - 1, big_ts,\
    sl_stop=0.1, ts_stop=0.1, tp_stop=0.1)
%timeit vbt.OHLCSTCX.run(\
    big_entries, big_ts, big_ts + 1, big_ts - 1, big_ts,\
    sl_stop=np.full(10, 0.1).tolist(), ts_stop=np.full(10, 0.1).tolist(), tp_stop=np.full(10, 0.1).tolist())
38.8 ms ± 1.07 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) 329 ms ± 728 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)