def test_unstable_period():
a = np.arange(10, dtype=float)
r = func.EMA(a, 3)
assert_np_arrays_equal(r, [np.nan, np.nan, 1, 2, 3, 4, 5, 6, 7, 8])
talib.set_unstable_period("EMA", 5)
r = func.EMA(a, 3)
assert_np_arrays_equal(r, [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, 6, 7, 8])
talib.set_unstable_period("EMA", 0)
def test_CDL3BLACKCROWS():
o = np.array([39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 40.32, 40.51, 38.09, 35.00, 27.66, 30.80])
h = np.array([40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 41.69, 40.84, 38.12, 35.50, 31.74, 32.51])
l = np.array([35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 39.26, 36.73, 33.37, 30.03, 27.03, 28.31])
c = np.array([40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.46, 37.08, 33.37, 30.03, 31.46, 28.31])
result = func.CDL3BLACKCROWS(o, h, l, c)
assert_np_arrays_equal(result, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -100, 0, 0])
def test_unstable_period():
a = np.arange(10, dtype=float)
r = func.EMA(a, 3)
assert_np_arrays_equal(r, [np.nan, np.nan, 1, 2, 3, 4, 5, 6, 7, 8])
talib.set_unstable_period('EMA', 5)
r = func.EMA(a, 3)
assert_np_arrays_equal(r, [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, 6, 7, 8])
talib.set_unstable_period('EMA', 0)
def test_CDL3BLACKCROWS():
o = np.array([39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 40.32, 40.51, 38.09, 35.00, 27.66, 30.80])
h = np.array([40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 41.69, 40.84, 38.12, 35.50, 31.74, 32.51])
l = np.array([35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 39.26, 36.73, 33.37, 30.03, 27.03, 28.31])
c = np.array([40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.46, 37.08, 33.37, 30.03, 31.46, 28.31])
result = func.CDL3BLACKCROWS(o, h, l, c)
assert_np_arrays_equal(result, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -100, 0, 0])
def test_compatibility():
a = np.arange(10, dtype=float)
talib.set_compatibility(0)
r = func.EMA(a, 3)
assert_np_arrays_equal(r, [np.nan, np.nan, 1, 2, 3, 4, 5, 6, 7, 8])
talib.set_compatibility(1)
r = func.EMA(a, 3)
assert_np_arrays_equal(r, [np.nan, np.nan,1.25,2.125,3.0625,4.03125,5.015625,6.0078125,7.00390625,8.001953125])
talib.set_compatibility(0)
def test_call_doesnt_cache_parameters():
sma = abstract.Function('SMA', timeperiod=10)
expected = func.SMA(ford_2012['close'], 20)
output = sma(ford_2012, timeperiod=20)
assert_np_arrays_equal(expected, output)
expected = func.SMA(ford_2012['close'], 10)
output = sma(ford_2012)
assert_np_arrays_equal(expected, output)
def test_call_doesnt_cache_parameters():
sma = abstract.Function('SMA', timeperiod=10)
expected = func.SMA(ford_2012['close'], 20)
output = sma(ford_2012, timeperiod=20)
assert_np_arrays_equal(expected, output)
expected = func.SMA(ford_2012['close'], 10)
output = sma(ford_2012)
assert_np_arrays_equal(expected, output)
def test_MIN():
result = func.MIN(series, timeperiod=4)
i = np.where(~np.isnan(result))[0][0]
assert len(series) == len(result)
assert result[i + 1] == 93.780
assert result[i + 2] == 93.780
assert result[i + 3] == 92.530
assert result[i + 4] == 92.530
values = np.array([np.nan, 5., 4., 3., 5., 7.])
result = func.MIN(values, timeperiod=2)
assert_np_arrays_equal(result, [np.nan, np.nan, 4, 3, 3, 5])
def test_MIN():
result = func.MIN(series, timeperiod=4)
i = np.where(~np.isnan(result))[0][0]
assert_equals(len(series), len(result))
assert_equals(result[i + 1], 93.780)
assert_equals(result[i + 2], 93.780)
assert_equals(result[i + 3], 92.530)
assert_equals(result[i + 4], 92.530)
values = np.array([np.nan, 5., 4., 3., 5., 7.])
result = func.MIN(values, timeperiod=2)
assert_np_arrays_equal(result, [np.nan, np.nan, 4, 3, 3, 5])
def test_MIN():
result = func.MIN(series, timeperiod=4)
i = np.where(~np.isnan(result))[0][0]
assert_equals(len(series), len(result))
assert_equals(result[i + 1], 93.780)
assert_equals(result[i + 2], 93.780)
assert_equals(result[i + 3], 92.530)
assert_equals(result[i + 4], 92.530)
values = np.array([np.nan, 5.0, 4.0, 3.0, 5.0, 7.0])
result = func.MIN(values, timeperiod=2)
assert_np_arrays_equal(result, [np.nan, np.nan, 4, 3, 3, 5])
def test_MAVP():
a = np.array(range(10), dtype=float)
b = np.array([2, 4], dtype=float)
result = func.MAVP(a, b)
assert_np_arrays_equal(result, [
np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan,
np.nan
])
result = func.MAVP(a, b, minperiod=2, maxperiod=4)
assert_np_arrays_equal(
result, [np.nan, np.nan, np.nan, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5])
def test_call_first_exception():
inputs = {'close': np.array([np.nan, np.nan, np.nan])}
with pytest.raises(Exception, match="inputs are all NaN"):
abstract.SMA(inputs, timeperiod=2)
inputs = {'close': np.array([1.0, 2.0, 3.0])}
output = abstract.SMA(inputs, timeperiod=2)
expected = np.array([np.nan, 1.5, 2.5])
assert_np_arrays_equal(expected, output)
def test_RSI():
a = np.array([0.00000024, 0.00000024, 0.00000024,
0.00000024, 0.00000024, 0.00000023,
0.00000024, 0.00000024, 0.00000024,
0.00000024, 0.00000023, 0.00000024,
0.00000023, 0.00000024, 0.00000023,
0.00000024, 0.00000024, 0.00000023,
0.00000023, 0.00000023], dtype='float64')
result = func.RSI(a, 10)
assert_np_arrays_equal(result, [np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,0,0,0,0,0,0,0,0,0,0])
result = func.RSI(a * 100000, 10)
assert_np_arrays_equal(result, [np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,33.333333333333329,51.351351351351347,39.491916859122398,51.84807024709005,42.25953803191981,52.101824405061215,52.101824405061215,43.043664867691085,43.043664867691085,43.043664867691085])
def test_SMA():
expected = func.SMA(ford_2012['close'], 10)
assert_np_arrays_equal(expected, abstract.Function('sma', ford_2012, 10).outputs)
assert_np_arrays_equal(expected, abstract.Function('sma')(ford_2012, 10, price='close'))
assert_np_arrays_equal(expected, abstract.Function('sma')(ford_2012, timeperiod=10))
expected = func.SMA(ford_2012['open'], 10)
assert_np_arrays_equal(expected, abstract.Function('sma', ford_2012, 10, price='open').outputs)
assert_np_arrays_equal(expected, abstract.Function('sma', price='low')(ford_2012, 10, price='open'))
assert_np_arrays_not_equal(expected, abstract.Function('sma', ford_2012, 10, price='open')(timeperiod=20))
assert_np_arrays_not_equal(expected, abstract.Function('sma', ford_2012)(10, price='close'))
assert_np_arrays_not_equal(expected, abstract.Function('sma', 10)(ford_2012, price='high'))
assert_np_arrays_not_equal(expected, abstract.Function('sma', price='low')(ford_2012, 10))
def test_compatibility():
a = np.arange(10, dtype=float)
talib.set_compatibility(0)
r = func.EMA(a, 3)
assert_np_arrays_equal(r, [np.nan, np.nan, 1, 2, 3, 4, 5, 6, 7, 8])
talib.set_compatibility(1)
r = func.EMA(a, 3)
assert_np_arrays_equal(r, [
np.nan, np.nan, 1.25, 2.125, 3.0625, 4.03125, 5.015625, 6.0078125,
7.00390625, 8.001953125
])
talib.set_compatibility(0)
def test_SMA():
expected = func.SMA(ford_2012["close"], 10)
assert_np_arrays_equal(expected, abstract.Function("sma", ford_2012, 10).outputs)
assert_np_arrays_equal(expected, abstract.Function("sma")(ford_2012, 10, price="close"))
assert_np_arrays_equal(expected, abstract.Function("sma")(ford_2012, timeperiod=10))
expected = func.SMA(ford_2012["open"], 10)
assert_np_arrays_equal(expected, abstract.Function("sma", ford_2012, 10, price="open").outputs)
assert_np_arrays_equal(expected, abstract.Function("sma", price="low")(ford_2012, 10, price="open"))
assert_np_arrays_not_equal(expected, abstract.Function("sma", ford_2012, 10, price="open")(timeperiod=20))
assert_np_arrays_not_equal(expected, abstract.Function("sma", ford_2012)(10, price="close"))
assert_np_arrays_not_equal(expected, abstract.Function("sma", 10)(ford_2012, price="high"))
assert_np_arrays_not_equal(expected, abstract.Function("sma", price="low")(ford_2012, 10))
def test_SMA():
expected = func.SMA(ford_2012['close'], 10)
assert_np_arrays_equal(expected, abstract.Function('sma', ford_2012, 10).outputs)
assert_np_arrays_equal(expected, abstract.Function('sma')(ford_2012, 10, price='close'))
assert_np_arrays_equal(expected, abstract.Function('sma')(ford_2012, timeperiod=10))
expected = func.SMA(ford_2012['open'], 10)
assert_np_arrays_equal(expected, abstract.Function('sma', ford_2012, 10, price='open').outputs)
assert_np_arrays_equal(expected, abstract.Function('sma', price='low')(ford_2012, 10, price='open'))
assert_np_arrays_not_equal(expected, abstract.Function('sma', ford_2012, 10, price='open')(timeperiod=20))
assert_np_arrays_not_equal(expected, abstract.Function('sma', ford_2012)(10, price='close'))
assert_np_arrays_not_equal(expected, abstract.Function('sma', 10)(ford_2012, price='high'))
assert_np_arrays_not_equal(expected, abstract.Function('sma', price='low')(ford_2012, 10))
def test_MAXINDEX():
import talib as func
import numpy as np
a = np.array(
[1., 2, 3, 4, 5, 6, 7, 8, 7, 7, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5, 15])
b = func.MA(a, 10)
c = func.MAXINDEX(b, 10)
assert_np_arrays_equal(
c,
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 16, 16, 21])
d = np.array([1., 2, 3])
e = func.MAXINDEX(d, 10)
assert_np_arrays_equal(e, [0, 0, 0])
def test_call_supports_same_signature_as_func_module():
adx = abstract.Function('ADX')
expected = func.ADX(ford_2012['open'], ford_2012['high'], ford_2012['low'])
output = adx(ford_2012['open'], ford_2012['high'], ford_2012['low'])
assert_np_arrays_equal(expected, output)
with assert_raises(TypeError) as e:
adx(ford_2012['open'], ford_2012['high'], ford_2012['low'], ford_2012['close'])
assert 'Too many price arguments: expected 3 (open, high, low)' in str(
e.exception.message)
with assert_raises(TypeError) as e:
adx(ford_2012['open'], ford_2012['high'])
assert 'Not enough price arguments: expected 3 (open, high, low)' in str(
e.exception.message)
def test_call_supports_same_signature_as_func_module():
adx = abstract.Function('ADX')
expected = func.ADX(ford_2012['open'], ford_2012['high'], ford_2012['low'])
output = adx(ford_2012['open'], ford_2012['high'], ford_2012['low'])
assert_np_arrays_equal(expected, output)
with assert_raises(TypeError) as e:
adx(ford_2012['open'], ford_2012['high'], ford_2012['low'],
ford_2012['close'])
assert 'Too many price arguments: expected 3 (open, high, low)' in str(
e.exception.message)
with assert_raises(TypeError) as e:
adx(ford_2012['open'], ford_2012['high'])
assert 'Not enough price arguments: expected 3 (open, high, low)' in str(
e.exception.message)
def test_MOM():
values = np.array([90.0, 88.0, 89.0])
result = func.MOM(values, timeperiod=1)
assert_np_arrays_equal(result, [np.nan, -2, 1])
result = func.MOM(values, timeperiod=2)
assert_np_arrays_equal(result, [np.nan, np.nan, -1])
result = func.MOM(values, timeperiod=3)
assert_np_arrays_equal(result, [np.nan, np.nan, np.nan])
result = func.MOM(values, timeperiod=4)
assert_np_arrays_equal(result, [np.nan, np.nan, np.nan])
def test_MOM():
values = np.array([90.0, 88.0, 89.0])
result = func.MOM(values, timeperiod=1)
assert_np_arrays_equal(result, [np.nan, -2, 1])
result = func.MOM(values, timeperiod=2)
assert_np_arrays_equal(result, [np.nan, np.nan, -1])
result = func.MOM(values, timeperiod=3)
assert_np_arrays_equal(result, [np.nan, np.nan, np.nan])
result = func.MOM(values, timeperiod=4)
assert_np_arrays_equal(result, [np.nan, np.nan, np.nan])
def test_input_nans():
a1 = np.arange(10, dtype=float)
a2 = np.arange(10, dtype=float)
a2[0] = np.nan
a2[1] = np.nan
r1, r2 = func.AROON(a1, a2, 2)
assert_np_arrays_equal(r1, [np.nan, np.nan, np.nan, np.nan, 0, 0, 0, 0, 0, 0])
assert_np_arrays_equal(r2, [np.nan, np.nan, np.nan, np.nan, 100, 100, 100, 100, 100, 100])
r1, r2 = func.AROON(a2, a1, 2)
assert_np_arrays_equal(r1, [np.nan, np.nan, np.nan, np.nan, 0, 0, 0, 0, 0, 0])
assert_np_arrays_equal(r2, [np.nan, np.nan, np.nan, np.nan, 100, 100, 100, 100, 100, 100])
def test_input_nans():
a1 = np.arange(10, dtype=float)
a2 = np.arange(10, dtype=float)
a2[0] = np.nan
a2[1] = np.nan
r1, r2 = func.AROON(a1, a2, 2)
assert_np_arrays_equal(r1, [np.nan, np.nan, np.nan, np.nan, 0, 0, 0, 0, 0, 0])
assert_np_arrays_equal(r2, [np.nan, np.nan, np.nan, np.nan, 100, 100, 100, 100, 100, 100])
r1, r2 = func.AROON(a2, a1, 2)
assert_np_arrays_equal(r1, [np.nan, np.nan, np.nan, np.nan, 0, 0, 0, 0, 0, 0])
assert_np_arrays_equal(r2, [np.nan, np.nan, np.nan, np.nan, 100, 100, 100, 100, 100, 100])
def test_call_supports_same_signature_as_func_module():
adx = abstract.Function('ADX')
expected = func.ADX(ford_2012['open'], ford_2012['high'], ford_2012['low'])
output = adx(ford_2012['open'], ford_2012['high'], ford_2012['low'])
assert_np_arrays_equal(expected, output)
expected_error = re.escape(
'Too many price arguments: expected 3 (high, low, close)')
with pytest.raises(TypeError, match=expected_error):
adx(ford_2012['open'], ford_2012['high'], ford_2012['low'],
ford_2012['close'])
expected_error = re.escape(
'Not enough price arguments: expected 3 (high, low, close)')
with pytest.raises(TypeError, match=expected_error):
adx(ford_2012['open'], ford_2012['high'])
def test_RSI():
a = np.array([
0.00000024, 0.00000024, 0.00000024, 0.00000024, 0.00000024, 0.00000023,
0.00000024, 0.00000024, 0.00000024, 0.00000024, 0.00000023, 0.00000024,
0.00000023, 0.00000024, 0.00000023, 0.00000024, 0.00000024, 0.00000023,
0.00000023, 0.00000023
],
dtype='float64')
result = func.RSI(a, 10)
assert_np_arrays_equal(result, [
np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan,
np.nan, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
])
result = func.RSI(a * 100000, 10)
assert_np_arrays_equal(result, [
np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan,
np.nan, 33.333333333333329, 51.351351351351347, 39.491916859122398,
51.84807024709005, 42.25953803191981, 52.101824405061215,
52.101824405061215, 43.043664867691085, 43.043664867691085,
43.043664867691085
])
def test_TEVA():
size = 50
df = pl.DataFrame({
"open":
np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"),
"high":
np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"),
"low":
np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"),
"close":
np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"),
"volume":
np.random.uniform(low=0.0, high=100.0, size=size).astype("float32")
})
tema1 = abstract.TEMA(df, timeperiod=9)
assert isinstance(tema1, pl.Series)
assert len(tema1) == 50
inputs = abstract.TEMA.get_input_arrays()
assert inputs.columns == df.columns
for column in df.columns:
assert_np_arrays_equal(inputs[column].to_numpy(),
df[column].to_numpy())
tema2 = abstract.TEMA(df, timeperiod=9)
assert isinstance(tema2, pl.Series)
assert len(tema2) == 50
inputs = abstract.TEMA.get_input_arrays()
assert inputs.columns == df.columns
for column in df.columns:
assert_np_arrays_equal(inputs[column].to_numpy(),
df[column].to_numpy())
assert_np_arrays_equal(tema1.to_numpy(), tema2.to_numpy())
def test_MOM():
values = pl.Series([90.0, 88.0, 89.0])
result = talib.MOM(values, timeperiod=1)
assert isinstance(result, pl.Series)
assert_np_arrays_equal(result.to_numpy(), [np.nan, -2, 1])
result = talib.MOM(values, timeperiod=2)
assert isinstance(result, pl.Series)
assert_np_arrays_equal(result.to_numpy(), [np.nan, np.nan, -1])
result = talib.MOM(values, timeperiod=3)
assert isinstance(result, pl.Series)
assert_np_arrays_equal(result.to_numpy(), [np.nan, np.nan, np.nan])
result = talib.MOM(values, timeperiod=4)
assert isinstance(result, pl.Series)
assert_np_arrays_equal(result.to_numpy(), [np.nan, np.nan, np.nan])
def test_MAVP():
a = np.array([1, 5, 3, 4, 7, 3, 8, 1, 4, 6], dtype=float)
b = np.array([2, 4, 2, 4, 2, 4, 2, 4, 2, 4], dtype=float)
result = func.MAVP(a, b, minperiod=2, maxperiod=4)
assert_np_arrays_equal(
result,
[np.nan, np.nan, np.nan, 3.25, 5.5, 4.25, 5.5, 4.75, 2.5, 4.75])
sma2 = func.SMA(a, 2)
assert_np_arrays_equal(result[4::2], sma2[4::2])
sma4 = func.SMA(a, 4)
assert_np_arrays_equal(result[3::2], sma4[3::2])
result = func.MAVP(a, b, minperiod=2, maxperiod=3)
assert_np_arrays_equal(result, [
np.nan, np.nan, 4, 4, 5.5, 4.666666666666667, 5.5, 4, 2.5,
3.6666666666666665
])
sma3 = func.SMA(a, 3)
assert_np_arrays_equal(result[2::2], sma2[2::2])
assert_np_arrays_equal(result[3::2], sma3[3::2])
def test_STOCH():
# check defaults match
expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'], ford_2012['close']) # 5, 3, 0, 3, 0
got_k, got_d = abstract.Function('stoch', ford_2012).outputs
assert_np_arrays_equal(expected_k, got_k)
assert_np_arrays_equal(expected_d, got_d)
expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'], ford_2012['close'])
got_k, got_d = abstract.Function('stoch', ford_2012)(5, 3, 0, 3, 0)
assert_np_arrays_equal(expected_k, got_k)
assert_np_arrays_equal(expected_d, got_d)
expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'], ford_2012['close'], 15)
got_k, got_d = abstract.Function('stoch', ford_2012)(15, 5, 0, 5, 0)
assert_np_arrays_not_equal(expected_k, got_k)
assert_np_arrays_not_equal(expected_d, got_d)
expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'], ford_2012['close'], 15, 5, 1, 5, 1)
got_k, got_d = abstract.Function('stoch', ford_2012)(15, 5, 1, 5, 1)
assert_np_arrays_equal(expected_k, got_k)
assert_np_arrays_equal(expected_d, got_d)
def test_doji_candle():
expected = func.CDLDOJI(ford_2012["open"], ford_2012["high"], ford_2012["low"], ford_2012["close"])
got = abstract.Function("CDLDOJI").run(ford_2012)
assert_np_arrays_equal(got, expected)
def test_doji_candle():
expected = func.CDLDOJI(ford_2012['open'], ford_2012['high'],
ford_2012['low'], ford_2012['close'])
got = abstract.Function('CDLDOJI').run(ford_2012)
assert_np_arrays_equal(got, expected)
def test_pandas():
import pandas
input_df = pandas.DataFrame(ford_2012)
input_dict = dict((k, pandas.Series(v)) for k, v in ford_2012.items())
expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'],
ford_2012['close']) # 5, 3, 0, 3, 0
output = abstract.Function('stoch', input_df).outputs
assert_true(isinstance(output, pandas.DataFrame))
assert_np_arrays_equal(expected_k, output['slowk'])
assert_np_arrays_equal(expected_d, output['slowd'])
output = abstract.Function('stoch', input_dict).outputs
assert_true(isinstance(output, list))
assert_np_arrays_equal(expected_k, output[0])
assert_np_arrays_equal(expected_d, output[1])
expected = func.SMA(ford_2012['close'], 10)
output = abstract.Function('sma', input_df, 10).outputs
assert_true(isinstance(output, pandas.Series))
assert_np_arrays_equal(expected, output)
output = abstract.Function('sma', input_dict, 10).outputs
assert_true(isinstance(output, np.ndarray))
assert_np_arrays_equal(expected, output)
def test_doji_candle():
expected = func.CDLDOJI(ford_2012['open'], ford_2012['high'], ford_2012['low'], ford_2012['close'])
got = abstract.Function('CDLDOJI').run(ford_2012)
assert_np_arrays_equal(got, expected)
def test_STOCH():
# check defaults match
expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'],
ford_2012['close']) # 5, 3, 0, 3, 0
got_k, got_d = abstract.Function('stoch', ford_2012).outputs
assert_np_arrays_equal(expected_k, got_k)
assert_np_arrays_equal(expected_d, got_d)
expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'],
ford_2012['close'])
got_k, got_d = abstract.Function('stoch', ford_2012)(5, 3, 0, 3, 0)
assert_np_arrays_equal(expected_k, got_k)
assert_np_arrays_equal(expected_d, got_d)
expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'],
ford_2012['close'], 15)
got_k, got_d = abstract.Function('stoch', ford_2012)(15, 5, 0, 5, 0)
assert_np_arrays_not_equal(expected_k, got_k)
assert_np_arrays_not_equal(expected_d, got_d)
expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'],
ford_2012['close'], 15, 5, 1, 5, 1)
got_k, got_d = abstract.Function('stoch', ford_2012)(15, 5, 1, 5, 1)
assert_np_arrays_equal(expected_k, got_k)
assert_np_arrays_equal(expected_d, got_d)
def test_MAVP():
a = pd.Series([1,5,3,4,7,3,8,1,4,6], index=range(10, 20), dtype=float)
b = pd.Series([2,4,2,4,2,4,2,4,2,4], index=range(20, 30), dtype=float)
result = talib.MAVP(a, b, minperiod=2, maxperiod=4)
assert_is_instance(result, pd.Series)
assert_np_arrays_equal(result.values, [np.nan,np.nan,np.nan,3.25,5.5,4.25,5.5,4.75,2.5,4.75])
assert_np_arrays_equal(result.index, range(10, 20))
sma2 = talib.SMA(a, 2)
assert_is_instance(sma2, pd.Series)
assert_np_arrays_equal(sma2.index, range(10, 20))
assert_np_arrays_equal(result.values[4::2], sma2.values[4::2])
sma4 = talib.SMA(a, 4)
assert_is_instance(sma4, pd.Series)
assert_np_arrays_equal(sma4.index, range(10, 20))
assert_np_arrays_equal(result.values[3::2], sma4.values[3::2])
result = talib.MAVP(a, b, minperiod=2, maxperiod=3)
assert_is_instance(result, pd.Series)
assert_np_arrays_equal(result.values, [np.nan,np.nan,4,4,5.5,4.666666666666667,5.5,4,2.5,3.6666666666666665])
assert_np_arrays_equal(result.index, range(10, 20))
sma3 = talib.SMA(a, 3)
assert_is_instance(sma3, pd.Series)
assert_np_arrays_equal(sma3.index, range(10, 20))
assert_np_arrays_equal(result.values[2::2], sma2.values[2::2])
assert_np_arrays_equal(result.values[3::2], sma3.values[3::2])
def test_MAVP():
a = pl.Series([1, 5, 3, 4, 7, 3, 8, 1, 4, 6], dtype=pl.Float64)
b = pl.Series([2, 4, 2, 4, 2, 4, 2, 4, 2, 4], dtype=pl.Float64)
result = talib.MAVP(a, b, minperiod=2, maxperiod=4)
assert isinstance(result, pl.Series)
assert_np_arrays_equal(
result.to_numpy(),
[np.nan, np.nan, np.nan, 3.25, 5.5, 4.25, 5.5, 4.75, 2.5, 4.75])
sma2 = talib.SMA(a, 2)
assert isinstance(sma2, pl.Series)
assert_np_arrays_equal(result.to_numpy()[4::2], sma2.to_numpy()[4::2])
sma4 = talib.SMA(a, 4)
assert isinstance(sma4, pl.Series)
assert_np_arrays_equal(result.to_numpy()[3::2], sma4.to_numpy()[3::2])
result = talib.MAVP(a, b, minperiod=2, maxperiod=3)
assert isinstance(result, pl.Series)
assert_np_arrays_equal(result.to_numpy(), [
np.nan, np.nan, 4, 4, 5.5, 4.666666666666667, 5.5, 4, 2.5,
3.6666666666666665
])
sma3 = talib.SMA(a, 3)
assert isinstance(sma3, pl.Series)
assert_np_arrays_equal(result.to_numpy()[2::2], sma2.to_numpy()[2::2])
assert_np_arrays_equal(result.to_numpy()[3::2], sma3.to_numpy()[3::2])
def test_MAVP():
a = pd.Series([1, 5, 3, 4, 7, 3, 8, 1, 4, 6],
index=range(10, 20),
dtype=float)
b = pd.Series([2, 4, 2, 4, 2, 4, 2, 4, 2, 4],
index=range(20, 30),
dtype=float)
result = talib.MAVP(a, b, minperiod=2, maxperiod=4)
assert isinstance(result, pd.Series)
assert_np_arrays_equal(
result.values,
[np.nan, np.nan, np.nan, 3.25, 5.5, 4.25, 5.5, 4.75, 2.5, 4.75])
assert_np_arrays_equal(result.index, range(10, 20))
sma2 = talib.SMA(a, 2)
assert isinstance(sma2, pd.Series)
assert_np_arrays_equal(sma2.index, range(10, 20))
assert_np_arrays_equal(result.values[4::2], sma2.values[4::2])
sma4 = talib.SMA(a, 4)
assert isinstance(sma4, pd.Series)
assert_np_arrays_equal(sma4.index, range(10, 20))
assert_np_arrays_equal(result.values[3::2], sma4.values[3::2])
result = talib.MAVP(a, b, minperiod=2, maxperiod=3)
assert isinstance(result, pd.Series)
assert_np_arrays_equal(result.values, [
np.nan, np.nan, 4, 4, 5.5, 4.666666666666667, 5.5, 4, 2.5,
3.6666666666666665
])
assert_np_arrays_equal(result.index, range(10, 20))
sma3 = talib.SMA(a, 3)
assert isinstance(sma3, pd.Series)
assert_np_arrays_equal(sma3.index, range(10, 20))
assert_np_arrays_equal(result.values[2::2], sma2.values[2::2])
assert_np_arrays_equal(result.values[3::2], sma3.values[3::2])
def test_MOM():
values = pd.Series([90.0, 88.0, 89.0], index=[10, 20, 30])
result = talib.MOM(values, timeperiod=1)
assert isinstance(result, pd.Series)
assert_np_arrays_equal(result.values, [np.nan, -2, 1])
assert_np_arrays_equal(result.index, [10, 20, 30])
result = talib.MOM(values, timeperiod=2)
assert isinstance(result, pd.Series)
assert_np_arrays_equal(result.values, [np.nan, np.nan, -1])
assert_np_arrays_equal(result.index, [10, 20, 30])
result = talib.MOM(values, timeperiod=3)
assert isinstance(result, pd.Series)
assert_np_arrays_equal(result.values, [np.nan, np.nan, np.nan])
assert_np_arrays_equal(result.index, [10, 20, 30])
result = talib.MOM(values, timeperiod=4)
assert isinstance(result, pd.Series)
assert_np_arrays_equal(result.values, [np.nan, np.nan, np.nan])
assert_np_arrays_equal(result.index, [10, 20, 30])
def test_MAVP():
a = np.array([1,5,3,4,7,3,8,1,4,6], dtype=float)
b = np.array([2,4,2,4,2,4,2,4,2,4], dtype=float)
result = func.MAVP(a, b, minperiod=2, maxperiod=4)
assert_np_arrays_equal(result, [np.nan,np.nan,np.nan,3.25,5.5,4.25,5.5,4.75,2.5,4.75])
sma2 = func.SMA(a, 2)
assert_np_arrays_equal(result[4::2], sma2[4::2])
sma4 = func.SMA(a, 4)
assert_np_arrays_equal(result[3::2], sma4[3::2])
result = func.MAVP(a, b, minperiod=2, maxperiod=3)
assert_np_arrays_equal(result, [np.nan,np.nan,4,4,5.5,4.666666666666667,5.5,4,2.5,3.6666666666666665])
sma3 = func.SMA(a, 3)
assert_np_arrays_equal(result[2::2], sma2[2::2])
assert_np_arrays_equal(result[3::2], sma3[3::2])
def test_pandas():
import pandas
input_df = pandas.DataFrame(ford_2012)
input_dict = dict((k, pandas.Series(v)) for k, v in ford_2012.items())
expected_k, expected_d = func.STOCH(ford_2012["high"], ford_2012["low"], ford_2012["close"]) # 5, 3, 0, 3, 0
output = abstract.Function("stoch", input_df).outputs
assert_true(isinstance(output, pandas.DataFrame))
assert_np_arrays_equal(expected_k, output["slowk"])
assert_np_arrays_equal(expected_d, output["slowd"])
output = abstract.Function("stoch", input_dict).outputs
assert_true(isinstance(output, list))
assert_np_arrays_equal(expected_k, output[0])
assert_np_arrays_equal(expected_d, output[1])
expected = func.SMA(ford_2012["close"], 10)
output = abstract.Function("sma", input_df, 10).outputs
assert_true(isinstance(output, pandas.Series))
assert_np_arrays_equal(expected, output)
output = abstract.Function("sma", input_dict, 10).outputs
assert_true(isinstance(output, np.ndarray))
assert_np_arrays_equal(expected, output)
def test_MOM():
values = pd.Series([90.0,88.0,89.0], index=[10, 20, 30])
result = talib.MOM(values, timeperiod=1)
assert_is_instance(result, pd.Series)
assert_np_arrays_equal(result.values, [np.nan, -2, 1])
assert_np_arrays_equal(result.index, [10, 20, 30])
result = talib.MOM(values, timeperiod=2)
assert_is_instance(result, pd.Series)
assert_np_arrays_equal(result.values, [np.nan, np.nan, -1])
assert_np_arrays_equal(result.index, [10, 20, 30])
result = talib.MOM(values, timeperiod=3)
assert_is_instance(result, pd.Series)
assert_np_arrays_equal(result.values, [np.nan, np.nan, np.nan])
assert_np_arrays_equal(result.index, [10, 20, 30])
result = talib.MOM(values, timeperiod=4)
assert_is_instance(result, pd.Series)
assert_np_arrays_equal(result.values, [np.nan, np.nan, np.nan])
assert_np_arrays_equal(result.index, [10, 20, 30])
