From 75659b42859fd1e89805654d6a10529683608910 Mon Sep 17 00:00:00 2001 From: mario4tier Date: Tue, 28 Jul 2026 22:54:27 -0400 Subject: [PATCH] feat: support TA-Lib C 0.8.1 TA-Lib C 0.8.1 is now the minimum required version. - Bind the 40 functions added since 0.7.1: 161 -> 201. - MA_Type gains HMA, DISABLED, DEFAULT, ZLEMA and RMA; set_unstable_period() gains RMA, HA and RVI. - generate_func.py / generate_stream.py: skip any declaration mentioning a TA__Stream handle. The verb list it replaces missed _Value and _Clone, which 0.8.1 declares for every function. - generate_func.py / generate_stream.py: a moving-average parameter not spelled exactly 'matype' -- KDJ's slowk_matype -- defaulted to SMA rather than to the function's own default, so func.KDJ and abstract.KDJ disagreed. - abstract: ignore flag bits added after this wrapper was written instead of raising KeyError, and keep the -100/0/100 wording for candlesticks only (SUPERTREND's integer output is a trend direction). - Building against an older ta-lib now fails at compile time; the import guard explains a stale extension. - Tests: func and abstract must agree on all 201, and the stubs must parse and cover every function. talib/_ta_lib.c is left untouched; it is refreshed at release time. Claude-Session: https://claude.ai/code/session_01R8JMZAcnp5snoMjFd1HyMU --- .github/workflows/wheels.yml | 2 +- CHANGELOG | 31 + talib/__init__.py | 74 +- talib/_abstract.pxi | 38 +- talib/_common.pxi | 13 +- talib/_func.pxi | 1458 ++++++++++++++++++++++++++++++-- talib/_stream.pxi | 1484 +++++++++++++++++++++++++++++++-- talib/_ta_lib.pxd | 93 ++- talib/_ta_lib.pyi | 523 +++++++++++- talib/abstract.pyi | 709 +++++++++++++++- talib/deprecated.py | 3 +- tests/test_abstract.py | 7 +- tests/test_func.py | 70 +- tests/test_stubs.py | 27 + tools/build_talib_linux.sh | 2 +- tools/build_talib_macos.sh | 2 +- tools/build_talib_windows.cmd | 2 +- tools/generate_func.py | 8 +- tools/generate_stream.py | 8 +- 19 files changed, 4335 insertions(+), 219 deletions(-) create mode 100644 tests/test_stubs.py diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml index 585187e4a..3a2aaae13 100644 --- a/.github/workflows/wheels.yml +++ b/.github/workflows/wheels.yml @@ -7,7 +7,7 @@ on: workflow_dispatch: env: - TALIB_C_VER: 0.7.1 + TALIB_C_VER: 0.8.1 PIP_NO_VERIFY: 0 PIP_VERBOSE: 1 CIBW_BEFORE_BUILD: pip install -U setuptools Cython wheel meson-python ninja && pip install -U numpy diff --git a/CHANGELOG b/CHANGELOG index 56676df11..508050060 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,34 @@ +0.8.0 +===== + +- [NEW]: Support TA-Lib C 0.8.1, which is now the minimum required version. + +- [NEW]: The 40 functions TA-Lib C added since 0.7.1: AC, ADR, AO, CMF, CMOU, + COPPOCK, CUMSUM, CVI, DONCHIAN, DPO, EFI, ER, ERI, FOSC, FRACTAL, HA, HMA, + KC, KDJ, MARKETFI, MASSI, NVI, PERCENTILE, PERCENTRANK, PVI, PVO, PVT, + QSTICK, RMA, RVI, RVOL, SMI, SUPERTREND, TSI, VHF, VORTEX, VWAP, VWMA, WAD, + ZLEMA. + +- [NEW]: New moving averages: ``MA_Type.HMA``, ``MA_Type.DISABLED``, + ``MA_Type.DEFAULT``, ``MA_Type.ZLEMA`` and ``MA_Type.RMA``. + +- [NEW]: ``set_unstable_period()`` and ``get_unstable_period()`` accept + ``'RMA'``, ``'HA'`` and ``'RVI'``. + +- [FIX]: ``abstract`` raised ``KeyError`` on function and output flags added + after this wrapper was written; unknown flag bits are now ignored. + +- [FIX]: A moving-average parameter not spelled exactly ``matype`` -- ``KDJ``'s + ``slowk_matype`` -- defaulted to SMA rather than to the function's own + documented default. + +- [FIX]: An ``integer`` output is documented as the candlestick -100/0/100 + convention only for candlestick functions; ``SUPERTREND``'s is a trend + direction. + +- [CHANGE]: ``APO`` and ``PPO`` now default ``matype`` to EMA, and ``BBANDS`` + defaults ``timeperiod`` to 20, following TA-Lib C 0.8.1. + 0.7.1 ===== diff --git a/talib/__init__.py b/talib/__init__.py index 63ac18cc9..5711e80df 100644 --- a/talib/__init__.py +++ b/talib/__init__.py @@ -106,14 +106,30 @@ def wrapper(*args, **kwds): _wrapper = lambda x: x -from ._ta_lib import ( - _ta_initialize, _ta_shutdown, MA_Type, __ta_version__, - _ta_set_unstable_period as set_unstable_period, - _ta_get_unstable_period as get_unstable_period, - _ta_set_compatibility as set_compatibility, - _ta_get_compatibility as get_compatibility, - __TA_FUNCTION_NAMES__ -) +# The TA-Lib C library this wrapper is built against +TA_LIB_C_REQUIRED = '0.8.1' + +try: + from ._ta_lib import ( + _ta_initialize, _ta_shutdown, MA_Type, __ta_version__, + _ta_set_unstable_period as set_unstable_period, + _ta_get_unstable_period as get_unstable_period, + _ta_set_compatibility as set_compatibility, + _ta_get_compatibility as get_compatibility, + __TA_FUNCTION_NAMES__ + ) +except ImportError as error: + # Loading the extension resolves its symbols against whatever TA-Lib C is + # installed. Linking never catches a too-old library -- a shared object may + # keep undefined symbols -- so a missing function shows up here instead, as + # "undefined symbol: TA_CMF_Lookback" or the macOS/Windows equivalent. + raise ImportError( + '%s\n\n' + 'talib could not load its extension module. This build requires the ' + 'TA-Lib C library %s or later; an older one is missing functions this ' + 'wrapper calls. See https://ta-lib.org/install/' + % (error, TA_LIB_C_REQUIRED) + ) from error # import all the func and stream functions from ._ta_lib import * @@ -154,6 +170,7 @@ def wrapper(*args, **kwds): ], 'Math Operators': [ 'ADD', + 'CUMSUM', 'DIV', 'MAX', 'MAXINDEX', @@ -183,16 +200,26 @@ def wrapper(*args, **kwds): 'TANH', ], 'Momentum Indicators': [ + 'AC', 'ADX', 'ADXR', + 'AO', 'APO', 'AROON', 'AROONOSC', 'BOP', 'CCI', 'CMO', + 'CMOU', + 'COPPOCK', + 'DPO', 'DX', + 'ER', + 'ERI', + 'FOSC', + 'FRACTAL', 'IMI', + 'KDJ', 'MACD', 'MACDEXT', 'MACDFIX', @@ -203,37 +230,50 @@ def wrapper(*args, **kwds): 'PLUS_DI', 'PLUS_DM', 'PPO', + 'QSTICK', 'ROC', 'ROCP', 'ROCR', 'ROCR100', 'RSI', + 'SMI', 'STOCH', 'STOCHF', 'STOCHRSI', 'TRIX', + 'TSI', 'ULTOSC', + 'VHF', + 'VORTEX', + 'WAD', 'WILLR', ], 'Overlap Studies': [ 'ACCBANDS', 'BBANDS', 'DEMA', + 'DONCHIAN', 'EMA', + 'HMA', 'HT_TRENDLINE', 'KAMA', + 'KC', 'MA', 'MAMA', 'MAVP', 'MIDPOINT', 'MIDPRICE', + 'RMA', 'SAR', 'SAREXT', 'SMA', + 'SUPERTREND', 'T3', 'TEMA', 'TRIMA', + 'VWMA', 'WMA', + 'ZLEMA', ], 'Pattern Recognition': [ 'CDL2CROWS', @@ -301,6 +341,7 @@ def wrapper(*args, **kwds): 'Price Transform': [ 'AVGDEV', 'AVGPRICE', + 'HA', 'MEDPRICE', 'TYPPRICE', 'WCLPRICE', @@ -312,19 +353,34 @@ def wrapper(*args, **kwds): 'LINEARREG_ANGLE', 'LINEARREG_INTERCEPT', 'LINEARREG_SLOPE', + 'PERCENTILE', + 'PERCENTRANK', 'STDDEV', 'TSF', 'VAR', ], 'Volatility Indicators': [ + 'ADR', 'ATR', + 'CVI', + 'MASSI', 'NATR', + 'RVI', 'TRANGE', ], 'Volume Indicators': [ 'AD', 'ADOSC', - 'OBV' + 'CMF', + 'EFI', + 'MARKETFI', + 'NVI', + 'OBV', + 'PVI', + 'PVO', + 'PVT', + 'RVOL', + 'VWAP', ], } diff --git a/talib/_abstract.pxi b/talib/_abstract.pxi index 6989ab80d..cec5c03c3 100644 --- a/talib/_abstract.pxi +++ b/talib/_abstract.pxi @@ -1,7 +1,6 @@ ''' This file Copyright (c) 2013 Brian A Cappello ''' -import math import threading try: from collections import OrderedDict @@ -592,30 +591,23 @@ def __get_flags(int flag, dict flags_lookup_dict): This function returns the flags from flag found in the provided flags_lookup_dict. """ - value_range = flags_lookup_dict.keys() - if not isinstance(value_range, list): - value_range = list(value_range) - min_int = int(math.log(min(value_range), 2)) - max_int = int(math.log(max(value_range), 2)) - - # if the flag we got is out-of-range, it just means no extra info provided - if flag < 1 or flag > 2**max_int: + # A bit with no description means the installed ta-lib is newer than this + # build knows about; skip it rather than raising. + if flag < 1: return None - - # In this loop, i is essentially the bit-position, which represents an - # input from flags_lookup_dict. We loop through as many flags_lookup_dict - # bit-positions as we need to check, bitwise-ANDing each with flag for a hit. - ret = [] - for i in xrange(min_int, max_int+1): - if 2**i & flag: - ret.append(flags_lookup_dict[2**i]) - return ret + return [description + for bit, description in sorted(flags_lookup_dict.items()) + if bit & flag] TA_FUNC_FLAGS = { + 1: 'A period of 1 performs no smoothing', 16777216: 'Output scale same as input', + 33554432: 'Function has a streaming API', 67108864: 'Output is over volume', 134217728: 'Function has an unstable period', - 268435456: 'Output is a candlestick' + 268435456: 'Output is a candlestick', + 536870912: 'Output is path-dependent', + 1073741824: 'Output can be NaN or infinite', } # when flag is 0, the function (should) work on any reasonable input ndarray @@ -642,7 +634,8 @@ TA_OUTPUT_FLAGS = { 512: 'Output can be negative', 1024: 'Output can be zero', 2048: 'Values represent an upper limit', - 4096: 'Values represent a lower limit' + 4096: 'Values represent a lower limit', + 8192: 'Output is optional (nullable)', } def _ta_getFuncInfo(char *function_name): @@ -754,13 +747,14 @@ def _get_defaults_and_docs(func_info): docs.append(' %s: %s' % (param, params[param])) func_args.append('[%s=%s]' % (param, params[param])) defaults[param] = params[param] - if param == 'matype': + if param.endswith('matype'): docs[-1] = ' '.join([docs[-1], '(%s)' % MA_Type[params[param]]]) outputs = func_info['output_names'] + candlestick = 'Output is a candlestick' in (func_info['function_flags'] or []) docs.append('Outputs:') for output in outputs: - if output == 'integer': + if output == 'integer' and candlestick: output = 'integer (values are -100, 0 or 100)' docs.append(' %s' % output) diff --git a/talib/_common.pxi b/talib/_common.pxi index 8c508d577..057d98013 100644 --- a/talib/_common.pxi +++ b/talib/_common.pxi @@ -40,6 +40,8 @@ cpdef _ta_check_success(str function_name, TA_RetCode ret_code): description = 'Bad Object (TA_BAD_OBJECT)' elif ret_code == 16: description = 'Not Supported (TA_NOT_SUPPORTED)' + elif ret_code == 17: + description = 'Insufficient History (TA_INSUFFICIENT_HISTORY)' elif ret_code == 5000: description = 'Internal Error (TA_INTERNAL_ERROR)' elif ret_code == 65535: @@ -60,7 +62,8 @@ def _ta_shutdown(): _ta_check_success('TA_Shutdown', ret_code) class MA_Type(object): - SMA, EMA, WMA, DEMA, TEMA, TRIMA, KAMA, MAMA, T3 = range(9) + SMA, EMA, WMA, DEMA, TEMA, TRIMA, KAMA, MAMA, T3, HMA, DISABLED, DEFAULT, \ + ZLEMA, RMA = range(14) def __init__(self): self._lookup = { @@ -73,6 +76,11 @@ class MA_Type(object): MA_Type.KAMA: 'Kaufman Adaptive Moving Average', MA_Type.MAMA: 'MESA Adaptive Moving Average', MA_Type.T3: 'Triple Generalized Double Exponential Moving Average', + MA_Type.HMA: 'Hull Moving Average', + MA_Type.DISABLED: 'No Moving Average (identity)', + MA_Type.DEFAULT: "The Function's Own Default Moving Average", + MA_Type.ZLEMA: 'Zero-Lag Exponential Moving Average', + MA_Type.RMA: "Wilder's Smoothed Moving Average", } def __getitem__(self, type_): @@ -107,6 +115,9 @@ _ta_func_unst_ids = { 'PLUS_DM': lib.TA_FUNC_UNST_PLUS_DM, 'RSI': lib.TA_FUNC_UNST_RSI, 'T3': lib.TA_FUNC_UNST_T3, + 'RMA': lib.TA_FUNC_UNST_RMA, + 'HA': lib.TA_FUNC_UNST_HA, + 'RVI': lib.TA_FUNC_UNST_RVI, 'ALL': lib.TA_FUNC_UNST_ALL, } diff --git a/talib/_func.pxi b/talib/_func.pxi index c4555a42c..742935d76 100644 --- a/talib/_func.pxi +++ b/talib/_func.pxi @@ -139,6 +139,40 @@ cdef np.ndarray make_int_array(np.npy_intp length, int lookback): return outinteger +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def AC( np.ndarray high not None , np.ndarray low not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int signalperiod=-2**31 ): + """ AC(high, low[, fastperiod=?, slowperiod=?, signalperiod=?]) + + Accelerator/Decelerator Oscillator (Momentum Indicators) + + Inputs: + prices: ['high', 'low'] + Parameters: + fastperiod: 5 + slowperiod: 34 + signalperiod: 5 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + high = check_array(high) + low = check_array(low) + length = check_length2(high, low) + begidx = check_begidx2(length, (high.data), (low.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_AC_Lookback( fastperiod , slowperiod , signalperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_AC( 0 , endidx , (high.data)+begidx , (low.data)+begidx , fastperiod , slowperiod , signalperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_AC", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def ACCBANDS( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): @@ -305,6 +339,38 @@ def ADOSC( np.ndarray high not None , np.ndarray low not None , np.ndarray close _ta_check_success("TA_ADOSC", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def ADR( np.ndarray high not None , np.ndarray low not None , int timeperiod=-2**31 ): + """ ADR(high, low[, timeperiod=?]) + + Average Day Range (Volatility Indicators) + + Inputs: + prices: ['high', 'low'] + Parameters: + timeperiod: 14 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + high = check_array(high) + low = check_array(low) + length = check_length2(high, low) + begidx = check_begidx2(length, (high.data), (low.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_ADR_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_ADR( 0 , endidx , (high.data)+begidx , (low.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_ADR", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def ADX( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): @@ -373,7 +439,40 @@ def ADXR( np.ndarray high not None , np.ndarray low not None , np.ndarray close @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function -def APO( np.ndarray real not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int matype=0 ): +def AO( np.ndarray high not None , np.ndarray low not None , int fastperiod=-2**31 , int slowperiod=-2**31 ): + """ AO(high, low[, fastperiod=?, slowperiod=?]) + + Awesome Oscillator (Momentum Indicators) + + Inputs: + prices: ['high', 'low'] + Parameters: + fastperiod: 5 + slowperiod: 34 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + high = check_array(high) + low = check_array(low) + length = check_length2(high, low) + begidx = check_begidx2(length, (high.data), (low.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_AO_Lookback( fastperiod , slowperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_AO( 0 , endidx , (high.data)+begidx , (low.data)+begidx , fastperiod , slowperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_AO", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def APO( np.ndarray real not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int matype=1 ): """ APO(real[, fastperiod=?, slowperiod=?, matype=?]) Absolute Price Oscillator (Momentum Indicators) @@ -383,7 +482,7 @@ def APO( np.ndarray real not None , int fastperiod=-2**31 , int slowperiod=-2**3 Parameters: fastperiod: 12 slowperiod: 26 - matype: 0 (Simple Moving Average) + matype: 1 (Exponential Moving Average) Outputs: real """ @@ -564,13 +663,15 @@ def ATR( np.ndarray high not None , np.ndarray low not None , np.ndarray close n @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function -def AVGPRICE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): - """ AVGPRICE(open, high, low, close) +def AVGDEV( np.ndarray real not None , int timeperiod=-2**31 ): + """ AVGDEV(real[, timeperiod=?]) - Average Price (Price Transform) + Average Deviation (Price Transform) Inputs: - prices: ['open', 'high', 'low', 'close'] + real: (any ndarray) + Parameters: + timeperiod: 14 Outputs: real """ @@ -581,30 +682,25 @@ def AVGPRICE( np.ndarray open not None , np.ndarray high not None , np.ndarray l int outbegidx int outnbelement np.ndarray outreal - open = check_array(open) - high = check_array(high) - low = check_array(low) - close = check_array(close) - length = check_length4(open, high, low, close) - begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) + real = check_array(real) + length = real.shape[0] + begidx = check_begidx1(length, (real.data)) endidx = length - begidx - 1 - lookback = begidx + lib.TA_AVGPRICE_Lookback( ) + lookback = begidx + lib.TA_AVGDEV_Lookback( timeperiod ) outreal = make_double_array(length, lookback) - retCode = lib.TA_AVGPRICE( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) - _ta_check_success("TA_AVGPRICE", retCode) + retCode = lib.TA_AVGDEV( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_AVGDEV", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function -def AVGDEV( np.ndarray real not None , int timeperiod=-2**31 ): - """ AVGDEV(real[, timeperiod=?]) +def AVGPRICE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): + """ AVGPRICE(open, high, low, close) - Average Deviation (Price Transform) + Average Price (Price Transform) Inputs: - real: (any ndarray) - Parameters: - timeperiod: 14 + prices: ['open', 'high', 'low', 'close'] Outputs: real """ @@ -615,14 +711,17 @@ def AVGDEV( np.ndarray real not None , int timeperiod=-2**31 ): int outbegidx int outnbelement np.ndarray outreal - real = check_array(real) - length = real.shape[0] - begidx = check_begidx1(length, (real.data)) + open = check_array(open) + high = check_array(high) + low = check_array(low) + close = check_array(close) + length = check_length4(open, high, low, close) + begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 - lookback = begidx + lib.TA_AVGDEV_Lookback( timeperiod ) + lookback = begidx + lib.TA_AVGPRICE_Lookback( ) outreal = make_double_array(length, lookback) - retCode = lib.TA_AVGDEV( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) - _ta_check_success("TA_AVGDEV", retCode) + retCode = lib.TA_AVGPRICE( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_AVGPRICE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @@ -635,7 +734,7 @@ def BBANDS( np.ndarray real not None , int timeperiod=-2**31 , double nbdevup=-4 Inputs: real: (any ndarray) Parameters: - timeperiod: 5 + timeperiod: 20 nbdevup: 2.0 nbdevdn: 2.0 matype: 0 (Simple Moving Average) @@ -864,7 +963,7 @@ def CDL3INSIDE( np.ndarray open not None , np.ndarray high not None , np.ndarray def CDL3LINESTRIKE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDL3LINESTRIKE(open, high, low, close) - Three-Line Strike (Pattern Recognition) + Three-Line Strike (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] @@ -2758,6 +2857,40 @@ def CEIL( np.ndarray real not None ): _ta_check_success("TA_CEIL", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def CMF( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , np.ndarray volume not None , int timeperiod=-2**31 ): + """ CMF(high, low, close, volume[, timeperiod=?]) + + Chaikin Money Flow (Volume Indicators) + + Inputs: + prices: ['high', 'low', 'close', 'volume'] + Parameters: + timeperiod: 20 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + high = check_array(high) + low = check_array(low) + close = check_array(close) + volume = check_array(volume) + length = check_length4(high, low, close, volume) + begidx = check_begidx4(length, (high.data), (low.data), (close.data), (volume.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_CMF_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_CMF( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , (volume.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_CMF", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CMO( np.ndarray real not None , int timeperiod=-2**31 ): @@ -2789,6 +2922,70 @@ def CMO( np.ndarray real not None , int timeperiod=-2**31 ): _ta_check_success("TA_CMO", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def CMOU( np.ndarray real not None , int timeperiod=-2**31 ): + """ CMOU(real[, timeperiod=?]) + + Chande Momentum Oscillator (Unsmoothed) (Momentum Indicators) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 14 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + real = check_array(real) + length = real.shape[0] + begidx = check_begidx1(length, (real.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_CMOU_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_CMOU( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_CMOU", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def COPPOCK( np.ndarray real not None , int wmaperiod=-2**31 , int roc1period=-2**31 , int roc2period=-2**31 ): + """ COPPOCK(real[, wmaperiod=?, roc1period=?, roc2period=?]) + + Coppock Curve (Momentum Indicators) + + Inputs: + real: (any ndarray) + Parameters: + wmaperiod: 10 + roc1period: 11 + roc2period: 14 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + real = check_array(real) + length = real.shape[0] + begidx = check_begidx1(length, (real.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_COPPOCK_Lookback( wmaperiod , roc1period , roc2period ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_COPPOCK( 0 , endidx , (real.data)+begidx , wmaperiod , roc1period , roc2period , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_COPPOCK", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CORREL( np.ndarray real0 not None , np.ndarray real1 not None , int timeperiod=-2**31 ): @@ -2880,6 +3077,68 @@ def COSH( np.ndarray real not None ): _ta_check_success("TA_COSH", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def CUMSUM( np.ndarray real not None ): + """ CUMSUM(real) + + Cumulative Sum (Math Operators) + + Inputs: + real: (any ndarray) + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + real = check_array(real) + length = real.shape[0] + begidx = check_begidx1(length, (real.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_CUMSUM_Lookback( ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_CUMSUM( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_CUMSUM", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def CVI( np.ndarray high not None , np.ndarray low not None , int timeperiod=-2**31 , int rocperiod=-2**31 ): + """ CVI(high, low[, timeperiod=?, rocperiod=?]) + + Chaikin's Volatility (Volatility Indicators) + + Inputs: + prices: ['high', 'low'] + Parameters: + timeperiod: 10 + rocperiod: 10 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + high = check_array(high) + low = check_array(low) + length = check_length2(high, low) + begidx = check_begidx2(length, (high.data), (low.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_CVI_Lookback( timeperiod , rocperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_CVI( 0 , endidx , (high.data)+begidx , (low.data)+begidx , timeperiod , rocperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_CVI", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def DEMA( np.ndarray real not None , int timeperiod=-2**31 ): @@ -2944,7 +3203,76 @@ def DIV( np.ndarray real0 not None , np.ndarray real1 not None ): @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function -def DX( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): +def DONCHIAN( np.ndarray high not None , np.ndarray low not None , int timeperiod=-2**31 ): + """ DONCHIAN(high, low[, timeperiod=?]) + + Donchian Channels (Overlap Studies) + + Inputs: + prices: ['high', 'low'] + Parameters: + timeperiod: 20 + Outputs: + upperband + middleband + lowerband + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outrealupperband + np.ndarray outrealmiddleband + np.ndarray outreallowerband + high = check_array(high) + low = check_array(low) + length = check_length2(high, low) + begidx = check_begidx2(length, (high.data), (low.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_DONCHIAN_Lookback( timeperiod ) + outrealupperband = make_double_array(length, lookback) + outrealmiddleband = make_double_array(length, lookback) + outreallowerband = make_double_array(length, lookback) + retCode = lib.TA_DONCHIAN( 0 , endidx , (high.data)+begidx , (low.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outrealupperband.data)+lookback , (outrealmiddleband.data)+lookback , (outreallowerband.data)+lookback ) + _ta_check_success("TA_DONCHIAN", retCode) + return outrealupperband , outrealmiddleband , outreallowerband + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def DPO( np.ndarray real not None , int timeperiod=-2**31 ): + """ DPO(real[, timeperiod=?]) + + Detrended Price Oscillator (Momentum Indicators) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 20 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + real = check_array(real) + length = real.shape[0] + begidx = check_begidx1(length, (real.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_DPO_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_DPO( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_DPO", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def DX( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ DX(high, low, close[, timeperiod=?]) Directional Movement Index (Momentum Indicators) @@ -2975,6 +3303,38 @@ def DX( np.ndarray high not None , np.ndarray low not None , np.ndarray close no _ta_check_success("TA_DX", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def EFI( np.ndarray close not None , np.ndarray volume not None , int timeperiod=-2**31 ): + """ EFI(close, volume[, timeperiod=?]) + + Elder's Force Index (Volume Indicators) + + Inputs: + prices: ['close', 'volume'] + Parameters: + timeperiod: 13 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + close = check_array(close) + volume = check_array(volume) + length = check_length2(close, volume) + begidx = check_begidx2(length, (close.data), (volume.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_EFI_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_EFI( 0 , endidx , (close.data)+begidx , (volume.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_EFI", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def EMA( np.ndarray real not None , int timeperiod=-2**31 ): @@ -3006,6 +3366,73 @@ def EMA( np.ndarray real not None , int timeperiod=-2**31 ): _ta_check_success("TA_EMA", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def ER( np.ndarray real not None , int timeperiod=-2**31 ): + """ ER(real[, timeperiod=?]) + + Kaufman Efficiency Ratio (Momentum Indicators) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 10 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + real = check_array(real) + length = real.shape[0] + begidx = check_begidx1(length, (real.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_ER_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_ER( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_ER", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def ERI( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): + """ ERI(high, low, close[, timeperiod=?]) + + Elder Ray Index (Bull Power / Bear Power) (Momentum Indicators) + + Inputs: + prices: ['high', 'low', 'close'] + Parameters: + timeperiod: 13 + Outputs: + bullpower + bearpower + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outbullpower + np.ndarray outbearpower + high = check_array(high) + low = check_array(low) + close = check_array(close) + length = check_length3(high, low, close) + begidx = check_begidx3(length, (high.data), (low.data), (close.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_ERI_Lookback( timeperiod ) + outbullpower = make_double_array(length, lookback) + outbearpower = make_double_array(length, lookback) + retCode = lib.TA_ERI( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outbullpower.data)+lookback , (outbearpower.data)+lookback ) + _ta_check_success("TA_ERI", retCode) + return outbullpower , outbearpower + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def EXP( np.ndarray real not None ): @@ -3064,6 +3491,145 @@ def FLOOR( np.ndarray real not None ): _ta_check_success("TA_FLOOR", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def FOSC( np.ndarray real not None , int timeperiod=-2**31 ): + """ FOSC(real[, timeperiod=?]) + + Forecast Oscillator (Momentum Indicators) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 5 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + real = check_array(real) + length = real.shape[0] + begidx = check_begidx1(length, (real.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_FOSC_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_FOSC( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_FOSC", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def FRACTAL( np.ndarray high not None , np.ndarray low not None , int leftbars=-2**31 , int rightbars=-2**31 ): + """ FRACTAL(high, low[, leftbars=?, rightbars=?]) + + Williams Fractal (Momentum Indicators) + + Inputs: + prices: ['high', 'low'] + Parameters: + leftbars: 2 + rightbars: 2 + Outputs: + swinghigh + swinglow + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outswinghigh + np.ndarray outswinglow + high = check_array(high) + low = check_array(low) + length = check_length2(high, low) + begidx = check_begidx2(length, (high.data), (low.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_FRACTAL_Lookback( leftbars , rightbars ) + outswinghigh = make_int_array(length, lookback) + outswinglow = make_int_array(length, lookback) + retCode = lib.TA_FRACTAL( 0 , endidx , (high.data)+begidx , (low.data)+begidx , leftbars , rightbars , &outbegidx , &outnbelement , (outswinghigh.data)+lookback , (outswinglow.data)+lookback ) + _ta_check_success("TA_FRACTAL", retCode) + return outswinghigh , outswinglow + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def HA( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): + """ HA(open, high, low, close) + + Heikin-Ashi Candles (Price Transform) + + Inputs: + prices: ['open', 'high', 'low', 'close'] + Outputs: + haopen + hahigh + halow + haclose + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outhaopen + np.ndarray outhahigh + np.ndarray outhalow + np.ndarray outhaclose + open = check_array(open) + high = check_array(high) + low = check_array(low) + close = check_array(close) + length = check_length4(open, high, low, close) + begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_HA_Lookback( ) + outhaopen = make_double_array(length, lookback) + outhahigh = make_double_array(length, lookback) + outhalow = make_double_array(length, lookback) + outhaclose = make_double_array(length, lookback) + retCode = lib.TA_HA( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outhaopen.data)+lookback , (outhahigh.data)+lookback , (outhalow.data)+lookback , (outhaclose.data)+lookback ) + _ta_check_success("TA_HA", retCode) + return outhaopen , outhahigh , outhalow , outhaclose + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def HMA( np.ndarray real not None , int timeperiod=-2**31 ): + """ HMA(real[, timeperiod=?]) + + Hull Moving Average (Overlap Studies) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 20 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + real = check_array(real) + length = real.shape[0] + begidx = check_begidx1(length, (real.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_HMA_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_HMA( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_HMA", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def HT_DCPERIOD( np.ndarray real not None ): @@ -3225,7 +3791,7 @@ def HT_TRENDMODE( np.ndarray real not None ): Inputs: real: (any ndarray) Outputs: - integer (values are -100, 0 or 100) + integer """ cdef: np.npy_intp length @@ -3307,6 +3873,90 @@ def KAMA( np.ndarray real not None , int timeperiod=-2**31 ): _ta_check_success("TA_KAMA", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def KC( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 , int atrperiod=-2**31 , double nbdev=-4e37 ): + """ KC(high, low, close[, timeperiod=?, atrperiod=?, nbdev=?]) + + Keltner Channels (Overlap Studies) + + Inputs: + prices: ['high', 'low', 'close'] + Parameters: + timeperiod: 20 + atrperiod: 10 + nbdev: 2.0 + Outputs: + upperband + middleband + lowerband + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outrealupperband + np.ndarray outrealmiddleband + np.ndarray outreallowerband + high = check_array(high) + low = check_array(low) + close = check_array(close) + length = check_length3(high, low, close) + begidx = check_begidx3(length, (high.data), (low.data), (close.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_KC_Lookback( timeperiod , atrperiod , nbdev ) + outrealupperband = make_double_array(length, lookback) + outrealmiddleband = make_double_array(length, lookback) + outreallowerband = make_double_array(length, lookback) + retCode = lib.TA_KC( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , timeperiod , atrperiod , nbdev , &outbegidx , &outnbelement , (outrealupperband.data)+lookback , (outrealmiddleband.data)+lookback , (outreallowerband.data)+lookback ) + _ta_check_success("TA_KC", retCode) + return outrealupperband , outrealmiddleband , outreallowerband + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def KDJ( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int fastk_period=-2**31 , int slowk_period=-2**31 , int slowk_matype=13 , int slowd_period=-2**31 , int slowd_matype=13 ): + """ KDJ(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?]) + + KDJ Stochastic (Momentum Indicators) + + Inputs: + prices: ['high', 'low', 'close'] + Parameters: + fastk_period: 9 + slowk_period: 3 + slowk_matype: 13 (Wilder's Smoothed Moving Average) + slowd_period: 3 + slowd_matype: 13 (Wilder's Smoothed Moving Average) + Outputs: + k + d + j + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outk + np.ndarray outd + np.ndarray outj + high = check_array(high) + low = check_array(low) + close = check_array(close) + length = check_length3(high, low, close) + begidx = check_begidx3(length, (high.data), (low.data), (close.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_KDJ_Lookback( fastk_period , slowk_period , slowk_matype , slowd_period , slowd_matype ) + outk = make_double_array(length, lookback) + outd = make_double_array(length, lookback) + outj = make_double_array(length, lookback) + retCode = lib.TA_KDJ( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , fastk_period , slowk_period , slowk_matype , slowd_period , slowd_matype , &outbegidx , &outnbelement , (outk.data)+lookback , (outd.data)+lookback , (outj.data)+lookback ) + _ta_check_success("TA_KDJ", retCode) + return outk , outd , outj + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def LINEARREG( np.ndarray real not None , int timeperiod=-2**31 ): @@ -3571,11 +4221,11 @@ def MACDEXT( np.ndarray real not None , int fastperiod=-2**31 , int fastmatype=0 real: (any ndarray) Parameters: fastperiod: 12 - fastmatype: 0 + fastmatype: 0 (Simple Moving Average) slowperiod: 26 - slowmatype: 0 + slowmatype: 0 (Simple Moving Average) signalperiod: 9 - signalmatype: 0 + signalmatype: 0 (Simple Moving Average) Outputs: macd macdsignal @@ -3674,6 +4324,70 @@ def MAMA( np.ndarray real not None , double fastlimit=-4e37 , double slowlimit=- _ta_check_success("TA_MAMA", retCode) return outmama , outfama +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def MARKETFI( np.ndarray high not None , np.ndarray low not None , np.ndarray volume not None ): + """ MARKETFI(high, low, volume) + + Market Facilitation Index (Volume Indicators) + + Inputs: + prices: ['high', 'low', 'volume'] + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + high = check_array(high) + low = check_array(low) + volume = check_array(volume) + length = check_length3(high, low, volume) + begidx = check_begidx3(length, (high.data), (low.data), (volume.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_MARKETFI_Lookback( ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_MARKETFI( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (volume.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_MARKETFI", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def MASSI( np.ndarray high not None , np.ndarray low not None , int fastperiod=-2**31 , int slowperiod=-2**31 ): + """ MASSI(high, low[, fastperiod=?, slowperiod=?]) + + Mass Index (Volatility Indicators) + + Inputs: + prices: ['high', 'low'] + Parameters: + fastperiod: 9 + slowperiod: 25 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + high = check_array(high) + low = check_array(low) + length = check_length2(high, low) + begidx = check_begidx2(length, (high.data), (low.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_MASSI_Lookback( fastperiod , slowperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_MASSI( 0 , endidx , (high.data)+begidx , (low.data)+begidx , fastperiod , slowperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_MASSI", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MAVP( np.ndarray real not None , np.ndarray periods not None , int minperiod=-2**31 , int maxperiod=-2**31 , int matype=0 ): @@ -3752,7 +4466,7 @@ def MAXINDEX( np.ndarray real not None , int timeperiod=-2**31 ): Parameters: timeperiod: 30 Outputs: - integer (values are -100, 0 or 100) + integer """ cdef: np.npy_intp length @@ -3944,7 +4658,7 @@ def MININDEX( np.ndarray real not None , int timeperiod=-2**31 ): Parameters: timeperiod: 30 Outputs: - integer (values are -100, 0 or 100) + integer """ cdef: np.npy_intp length @@ -4200,6 +4914,36 @@ def NATR( np.ndarray high not None , np.ndarray low not None , np.ndarray close _ta_check_success("TA_NATR", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def NVI( np.ndarray close not None , np.ndarray volume not None ): + """ NVI(close, volume) + + Negative Volume Index (Volume Indicators) + + Inputs: + prices: ['close', 'volume'] + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + close = check_array(close) + volume = check_array(volume) + length = check_length2(close, volume) + begidx = check_begidx2(length, (close.data), (volume.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_NVI_Lookback( ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_NVI( 0 , endidx , (close.data)+begidx , (volume.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_NVI", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def OBV( np.ndarray real not None , np.ndarray volume not None ): @@ -4231,6 +4975,69 @@ def OBV( np.ndarray real not None , np.ndarray volume not None ): _ta_check_success("TA_OBV", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def PERCENTILE( np.ndarray real not None , int timeperiod=-2**31 , double percentile=50.0 ): + """ PERCENTILE(real[, timeperiod=?, percentile=?]) + + Percentile (nearest rank) (Statistic Functions) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 30 + percentile: 50.0 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + real = check_array(real) + length = real.shape[0] + begidx = check_begidx1(length, (real.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_PERCENTILE_Lookback( timeperiod , percentile ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_PERCENTILE( 0 , endidx , (real.data)+begidx , timeperiod , percentile , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_PERCENTILE", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def PERCENTRANK( np.ndarray real not None , int timeperiod=-2**31 ): + """ PERCENTRANK(real[, timeperiod=?]) + + Percent Rank (Statistic Functions) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 100 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + real = check_array(real) + length = real.shape[0] + begidx = check_begidx1(length, (real.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_PERCENTRANK_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_PERCENTRANK( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_PERCENTRANK", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def PLUS_DI( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): @@ -4298,7 +5105,7 @@ def PLUS_DM( np.ndarray high not None , np.ndarray low not None , int timeperiod @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function -def PPO( np.ndarray real not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int matype=0 ): +def PPO( np.ndarray real not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int matype=1 ): """ PPO(real[, fastperiod=?, slowperiod=?, matype=?]) Percentage Price Oscillator (Momentum Indicators) @@ -4308,7 +5115,7 @@ def PPO( np.ndarray real not None , int fastperiod=-2**31 , int slowperiod=-2**3 Parameters: fastperiod: 12 slowperiod: 26 - matype: 0 (Simple Moving Average) + matype: 1 (Exponential Moving Average) Outputs: real """ @@ -4329,6 +5136,162 @@ def PPO( np.ndarray real not None , int fastperiod=-2**31 , int slowperiod=-2**3 _ta_check_success("TA_PPO", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def PVI( np.ndarray close not None , np.ndarray volume not None ): + """ PVI(close, volume) + + Positive Volume Index (Volume Indicators) + + Inputs: + prices: ['close', 'volume'] + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + close = check_array(close) + volume = check_array(volume) + length = check_length2(close, volume) + begidx = check_begidx2(length, (close.data), (volume.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_PVI_Lookback( ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_PVI( 0 , endidx , (close.data)+begidx , (volume.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_PVI", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def PVO( np.ndarray volume not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int matype=1 ): + """ PVO(volume[, fastperiod=?, slowperiod=?, matype=?]) + + Percentage Volume Oscillator (Volume Indicators) + + Inputs: + prices: ['volume'] + Parameters: + fastperiod: 12 + slowperiod: 26 + matype: 1 (Exponential Moving Average) + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + volume = check_array(volume) + length = volume.shape[0] + begidx = check_begidx1(length, (volume.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_PVO_Lookback( fastperiod , slowperiod , matype ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_PVO( 0 , endidx , (volume.data)+begidx , fastperiod , slowperiod , matype , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_PVO", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def PVT( np.ndarray close not None , np.ndarray volume not None ): + """ PVT(close, volume) + + Price Volume Trend (Volume Indicators) + + Inputs: + prices: ['close', 'volume'] + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + close = check_array(close) + volume = check_array(volume) + length = check_length2(close, volume) + begidx = check_begidx2(length, (close.data), (volume.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_PVT_Lookback( ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_PVT( 0 , endidx , (close.data)+begidx , (volume.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_PVT", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def QSTICK( np.ndarray open not None , np.ndarray close not None , int timeperiod=-2**31 ): + """ QSTICK(open, close[, timeperiod=?]) + + Qstick (Momentum Indicators) + + Inputs: + prices: ['open', 'close'] + Parameters: + timeperiod: 10 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + open = check_array(open) + close = check_array(close) + length = check_length2(open, close) + begidx = check_begidx2(length, (open.data), (close.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_QSTICK_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_QSTICK( 0 , endidx , (open.data)+begidx , (close.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_QSTICK", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def RMA( np.ndarray real not None , int timeperiod=-2**31 ): + """ RMA(real[, timeperiod=?]) + + Wilder's Smoothed Moving Average (Overlap Studies) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 30 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + real = check_array(real) + length = real.shape[0] + begidx = check_begidx1(length, (real.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_RMA_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_RMA( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_RMA", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def ROC( np.ndarray real not None , int timeperiod=-2**31 ): @@ -4401,7 +5364,69 @@ def ROCR( np.ndarray real not None , int timeperiod=-2**31 ): Inputs: real: (any ndarray) Parameters: - timeperiod: 10 + timeperiod: 10 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + real = check_array(real) + length = real.shape[0] + begidx = check_begidx1(length, (real.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_ROCR_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_ROCR( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_ROCR", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def ROCR100( np.ndarray real not None , int timeperiod=-2**31 ): + """ ROCR100(real[, timeperiod=?]) + + Rate of change ratio 100 scale: (real/prevPrice)*100 (Momentum Indicators) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 10 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + real = check_array(real) + length = real.shape[0] + begidx = check_begidx1(length, (real.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_ROCR100_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_ROCR100( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_ROCR100", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def RSI( np.ndarray real not None , int timeperiod=-2**31 ): + """ RSI(real[, timeperiod=?]) + + Relative Strength Index (Momentum Indicators) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 14 Outputs: real """ @@ -4416,23 +5441,24 @@ def ROCR( np.ndarray real not None , int timeperiod=-2**31 ): length = real.shape[0] begidx = check_begidx1(length, (real.data)) endidx = length - begidx - 1 - lookback = begidx + lib.TA_ROCR_Lookback( timeperiod ) + lookback = begidx + lib.TA_RSI_Lookback( timeperiod ) outreal = make_double_array(length, lookback) - retCode = lib.TA_ROCR( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) - _ta_check_success("TA_ROCR", retCode) + retCode = lib.TA_RSI( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_RSI", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function -def ROCR100( np.ndarray real not None , int timeperiod=-2**31 ): - """ ROCR100(real[, timeperiod=?]) +def RVI( np.ndarray real not None , int timeperiod=-2**31 , int stddevperiod=-2**31 ): + """ RVI(real[, timeperiod=?, stddevperiod=?]) - Rate of change ratio 100 scale: (real/prevPrice)*100 (Momentum Indicators) + Relative Volatility Index (Volatility Indicators) Inputs: real: (any ndarray) Parameters: - timeperiod: 10 + timeperiod: 14 + stddevperiod: 10 Outputs: real """ @@ -4447,23 +5473,23 @@ def ROCR100( np.ndarray real not None , int timeperiod=-2**31 ): length = real.shape[0] begidx = check_begidx1(length, (real.data)) endidx = length - begidx - 1 - lookback = begidx + lib.TA_ROCR100_Lookback( timeperiod ) + lookback = begidx + lib.TA_RVI_Lookback( timeperiod , stddevperiod ) outreal = make_double_array(length, lookback) - retCode = lib.TA_ROCR100( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) - _ta_check_success("TA_ROCR100", retCode) + retCode = lib.TA_RVI( 0 , endidx , (real.data)+begidx , timeperiod , stddevperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_RVI", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function -def RSI( np.ndarray real not None , int timeperiod=-2**31 ): - """ RSI(real[, timeperiod=?]) +def RVOL( np.ndarray volume not None , int timeperiod=-2**31 ): + """ RVOL(volume[, timeperiod=?]) - Relative Strength Index (Momentum Indicators) + Relative Volume (Volume Indicators) Inputs: - real: (any ndarray) + prices: ['volume'] Parameters: - timeperiod: 14 + timeperiod: 20 Outputs: real """ @@ -4474,14 +5500,14 @@ def RSI( np.ndarray real not None , int timeperiod=-2**31 ): int outbegidx int outnbelement np.ndarray outreal - real = check_array(real) - length = real.shape[0] - begidx = check_begidx1(length, (real.data)) + volume = check_array(volume) + length = volume.shape[0] + begidx = check_begidx1(length, (volume.data)) endidx = length - begidx - 1 - lookback = begidx + lib.TA_RSI_Lookback( timeperiod ) + lookback = begidx + lib.TA_RVOL_Lookback( timeperiod ) outreal = make_double_array(length, lookback) - retCode = lib.TA_RSI( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) - _ta_check_success("TA_RSI", retCode) + retCode = lib.TA_RVOL( 0 , endidx , (volume.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_RVOL", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @@ -4645,6 +5671,45 @@ def SMA( np.ndarray real not None , int timeperiod=-2**31 ): _ta_check_success("TA_SMA", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def SMI( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 , int fastperiod=-2**31 , int slowperiod=-2**31 , int signalperiod=-2**31 ): + """ SMI(high, low, close[, timeperiod=?, fastperiod=?, slowperiod=?, signalperiod=?]) + + Stochastic Momentum Index (Momentum Indicators) + + Inputs: + prices: ['high', 'low', 'close'] + Parameters: + timeperiod: 13 + fastperiod: 2 + slowperiod: 25 + signalperiod: 9 + Outputs: + smi + smisignal + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outsmi + np.ndarray outsmisignal + high = check_array(high) + low = check_array(low) + close = check_array(close) + length = check_length3(high, low, close) + begidx = check_begidx3(length, (high.data), (low.data), (close.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_SMI_Lookback( timeperiod , fastperiod , slowperiod , signalperiod ) + outsmi = make_double_array(length, lookback) + outsmisignal = make_double_array(length, lookback) + retCode = lib.TA_SMI( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , timeperiod , fastperiod , slowperiod , signalperiod , &outbegidx , &outnbelement , (outsmi.data)+lookback , (outsmisignal.data)+lookback ) + _ta_check_success("TA_SMI", retCode) + return outsmi , outsmisignal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def SQRT( np.ndarray real not None ): @@ -4718,9 +5783,9 @@ def STOCH( np.ndarray high not None , np.ndarray low not None , np.ndarray close Parameters: fastk_period: 5 slowk_period: 3 - slowk_matype: 0 + slowk_matype: 0 (Simple Moving Average) slowd_period: 3 - slowd_matype: 0 + slowd_matype: 0 (Simple Moving Average) Outputs: slowk slowd @@ -4758,7 +5823,7 @@ def STOCHF( np.ndarray high not None , np.ndarray low not None , np.ndarray clos Parameters: fastk_period: 5 fastd_period: 3 - fastd_matype: 0 + fastd_matype: 0 (Simple Moving Average) Outputs: fastk fastd @@ -4797,7 +5862,7 @@ def STOCHRSI( np.ndarray real not None , int timeperiod=-2**31 , int fastk_perio timeperiod: 14 fastk_period: 5 fastd_period: 3 - fastd_matype: 0 + fastd_matype: 0 (Simple Moving Average) Outputs: fastk fastd @@ -4883,6 +5948,43 @@ def SUM( np.ndarray real not None , int timeperiod=-2**31 ): _ta_check_success("TA_SUM", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def SUPERTREND( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 , double multiplier=3.0 ): + """ SUPERTREND(high, low, close[, timeperiod=?, multiplier=?]) + + SuperTrend (Overlap Studies) + + Inputs: + prices: ['high', 'low', 'close'] + Parameters: + timeperiod: 10 + multiplier: 3.0 + Outputs: + real + integer + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + np.ndarray outinteger + high = check_array(high) + low = check_array(low) + close = check_array(close) + length = check_length3(high, low, close) + begidx = check_begidx3(length, (high.data), (low.data), (close.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_SUPERTREND_Lookback( timeperiod , multiplier ) + outreal = make_double_array(length, lookback) + outinteger = make_int_array(length, lookback) + retCode = lib.TA_SUPERTREND( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , timeperiod , multiplier , &outbegidx , &outnbelement , (outreal.data)+lookback , (outinteger.data)+lookback ) + _ta_check_success("TA_SUPERTREND", retCode) + return outreal , outinteger + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def T3( np.ndarray real not None , int timeperiod=-2**31 , double vfactor=-4e37 ): @@ -5128,6 +6230,38 @@ def TSF( np.ndarray real not None , int timeperiod=-2**31 ): _ta_check_success("TA_TSF", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def TSI( np.ndarray real not None , int firstperiod=-2**31 , int secondperiod=-2**31 ): + """ TSI(real[, firstperiod=?, secondperiod=?]) + + True Strength Index (Momentum Indicators) + + Inputs: + real: (any ndarray) + Parameters: + firstperiod: 25 + secondperiod: 13 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + real = check_array(real) + length = real.shape[0] + begidx = check_begidx1(length, (real.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_TSI_Lookback( firstperiod , secondperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_TSI( 0 , endidx , (real.data)+begidx , firstperiod , secondperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_TSI", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def TYPPRICE( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): @@ -5226,6 +6360,169 @@ def VAR( np.ndarray real not None , int timeperiod=-2**31 , double nbdev=-4e37 ) _ta_check_success("TA_VAR", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def VHF( np.ndarray real not None , int timeperiod=-2**31 ): + """ VHF(real[, timeperiod=?]) + + Vertical Horizontal Filter (Momentum Indicators) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 28 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + real = check_array(real) + length = real.shape[0] + begidx = check_begidx1(length, (real.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_VHF_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_VHF( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_VHF", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def VORTEX( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): + """ VORTEX(high, low, close[, timeperiod=?]) + + Vortex Indicator (Momentum Indicators) + + Inputs: + prices: ['high', 'low', 'close'] + Parameters: + timeperiod: 14 + Outputs: + plusvi + minusvi + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outplusvi + np.ndarray outminusvi + high = check_array(high) + low = check_array(low) + close = check_array(close) + length = check_length3(high, low, close) + begidx = check_begidx3(length, (high.data), (low.data), (close.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_VORTEX_Lookback( timeperiod ) + outplusvi = make_double_array(length, lookback) + outminusvi = make_double_array(length, lookback) + retCode = lib.TA_VORTEX( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outplusvi.data)+lookback , (outminusvi.data)+lookback ) + _ta_check_success("TA_VORTEX", retCode) + return outplusvi , outminusvi + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def VWAP( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , np.ndarray volume not None ): + """ VWAP(high, low, close, volume) + + Volume Weighted Average Price (Volume Indicators) + + Inputs: + prices: ['high', 'low', 'close', 'volume'] + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + high = check_array(high) + low = check_array(low) + close = check_array(close) + volume = check_array(volume) + length = check_length4(high, low, close, volume) + begidx = check_begidx4(length, (high.data), (low.data), (close.data), (volume.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_VWAP_Lookback( ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_VWAP( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , (volume.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_VWAP", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def VWMA( np.ndarray real not None , np.ndarray volume not None , int timeperiod=-2**31 ): + """ VWMA(real, volume[, timeperiod=?]) + + Volume Weighted Moving Average (Overlap Studies) + + Inputs: + real: (any ndarray) + prices: ['volume'] + Parameters: + timeperiod: 30 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + real = check_array(real) + volume = check_array(volume) + length = check_length2(real, volume) + begidx = check_begidx2(length, (real.data), (volume.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_VWMA_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_VWMA( 0 , endidx , (real.data)+begidx , (volume.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_VWMA", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def WAD( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): + """ WAD(high, low, close) + + Williams' Accumulation/Distribution (Momentum Indicators) + + Inputs: + prices: ['high', 'low', 'close'] + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + high = check_array(high) + low = check_array(low) + close = check_array(close) + length = check_length3(high, low, close) + begidx = check_begidx3(length, (high.data), (low.data), (close.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_WAD_Lookback( ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_WAD( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_WAD", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def WCLPRICE( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): @@ -5321,4 +6618,35 @@ def WMA( np.ndarray real not None , int timeperiod=-2**31 ): _ta_check_success("TA_WMA", retCode) return outreal -__TA_FUNCTION_NAMES__ = ["ACCBANDS","ACOS","AD","ADD","ADOSC","ADX","ADXR","APO","AROON","AROONOSC","ASIN","ATAN","ATR","AVGPRICE","AVGDEV","BBANDS","BETA","BOP","CCI","CDL2CROWS","CDL3BLACKCROWS","CDL3INSIDE","CDL3LINESTRIKE","CDL3OUTSIDE","CDL3STARSINSOUTH","CDL3WHITESOLDIERS","CDLABANDONEDBABY","CDLADVANCEBLOCK","CDLBELTHOLD","CDLBREAKAWAY","CDLCLOSINGMARUBOZU","CDLCONCEALBABYSWALL","CDLCOUNTERATTACK","CDLDARKCLOUDCOVER","CDLDOJI","CDLDOJISTAR","CDLDRAGONFLYDOJI","CDLENGULFING","CDLEVENINGDOJISTAR","CDLEVENINGSTAR","CDLGAPSIDESIDEWHITE","CDLGRAVESTONEDOJI","CDLHAMMER","CDLHANGINGMAN","CDLHARAMI","CDLHARAMICROSS","CDLHIGHWAVE","CDLHIKKAKE","CDLHIKKAKEMOD","CDLHOMINGPIGEON","CDLIDENTICAL3CROWS","CDLINNECK","CDLINVERTEDHAMMER","CDLKICKING","CDLKICKINGBYLENGTH","CDLLADDERBOTTOM","CDLLONGLEGGEDDOJI","CDLLONGLINE","CDLMARUBOZU","CDLMATCHINGLOW","CDLMATHOLD","CDLMORNINGDOJISTAR","CDLMORNINGSTAR","CDLONNECK","CDLPIERCING","CDLRICKSHAWMAN","CDLRISEFALL3METHODS","CDLSEPARATINGLINES","CDLSHOOTINGSTAR","CDLSHORTLINE","CDLSPINNINGTOP","CDLSTALLEDPATTERN","CDLSTICKSANDWICH","CDLTAKURI","CDLTASUKIGAP","CDLTHRUSTING","CDLTRISTAR","CDLUNIQUE3RIVER","CDLUPSIDEGAP2CROWS","CDLXSIDEGAP3METHODS","CEIL","CMO","CORREL","COS","COSH","DEMA","DIV","DX","EMA","EXP","FLOOR","HT_DCPERIOD","HT_DCPHASE","HT_PHASOR","HT_SINE","HT_TRENDLINE","HT_TRENDMODE","IMI","KAMA","LINEARREG","LINEARREG_ANGLE","LINEARREG_INTERCEPT","LINEARREG_SLOPE","LN","LOG10","MA","MACD","MACDEXT","MACDFIX","MAMA","MAVP","MAX","MAXINDEX","MEDPRICE","MFI","MIDPOINT","MIDPRICE","MIN","MININDEX","MINMAX","MINMAXINDEX","MINUS_DI","MINUS_DM","MOM","MULT","NATR","OBV","PLUS_DI","PLUS_DM","PPO","ROC","ROCP","ROCR","ROCR100","RSI","SAR","SAREXT","SIN","SINH","SMA","SQRT","STDDEV","STOCH","STOCHF","STOCHRSI","SUB","SUM","T3","TAN","TANH","TEMA","TRANGE","TRIMA","TRIX","TSF","TYPPRICE","ULTOSC","VAR","WCLPRICE","WILLR","WMA"] +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def ZLEMA( np.ndarray real not None , int timeperiod=-2**31 ): + """ ZLEMA(real[, timeperiod=?]) + + Zero-Lag Exponential Moving Average (Overlap Studies) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 30 + Outputs: + real + """ + cdef: + np.npy_intp length + int begidx, endidx, lookback + TA_RetCode retCode + int outbegidx + int outnbelement + np.ndarray outreal + real = check_array(real) + length = real.shape[0] + begidx = check_begidx1(length, (real.data)) + endidx = length - begidx - 1 + lookback = begidx + lib.TA_ZLEMA_Lookback( timeperiod ) + outreal = make_double_array(length, lookback) + retCode = lib.TA_ZLEMA( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) + _ta_check_success("TA_ZLEMA", retCode) + return outreal + +__TA_FUNCTION_NAMES__ = ["AC","ACCBANDS","ACOS","AD","ADD","ADOSC","ADR","ADX","ADXR","AO","APO","AROON","AROONOSC","ASIN","ATAN","ATR","AVGDEV","AVGPRICE","BBANDS","BETA","BOP","CCI","CDL2CROWS","CDL3BLACKCROWS","CDL3INSIDE","CDL3LINESTRIKE","CDL3OUTSIDE","CDL3STARSINSOUTH","CDL3WHITESOLDIERS","CDLABANDONEDBABY","CDLADVANCEBLOCK","CDLBELTHOLD","CDLBREAKAWAY","CDLCLOSINGMARUBOZU","CDLCONCEALBABYSWALL","CDLCOUNTERATTACK","CDLDARKCLOUDCOVER","CDLDOJI","CDLDOJISTAR","CDLDRAGONFLYDOJI","CDLENGULFING","CDLEVENINGDOJISTAR","CDLEVENINGSTAR","CDLGAPSIDESIDEWHITE","CDLGRAVESTONEDOJI","CDLHAMMER","CDLHANGINGMAN","CDLHARAMI","CDLHARAMICROSS","CDLHIGHWAVE","CDLHIKKAKE","CDLHIKKAKEMOD","CDLHOMINGPIGEON","CDLIDENTICAL3CROWS","CDLINNECK","CDLINVERTEDHAMMER","CDLKICKING","CDLKICKINGBYLENGTH","CDLLADDERBOTTOM","CDLLONGLEGGEDDOJI","CDLLONGLINE","CDLMARUBOZU","CDLMATCHINGLOW","CDLMATHOLD","CDLMORNINGDOJISTAR","CDLMORNINGSTAR","CDLONNECK","CDLPIERCING","CDLRICKSHAWMAN","CDLRISEFALL3METHODS","CDLSEPARATINGLINES","CDLSHOOTINGSTAR","CDLSHORTLINE","CDLSPINNINGTOP","CDLSTALLEDPATTERN","CDLSTICKSANDWICH","CDLTAKURI","CDLTASUKIGAP","CDLTHRUSTING","CDLTRISTAR","CDLUNIQUE3RIVER","CDLUPSIDEGAP2CROWS","CDLXSIDEGAP3METHODS","CEIL","CMF","CMO","CMOU","COPPOCK","CORREL","COS","COSH","CUMSUM","CVI","DEMA","DIV","DONCHIAN","DPO","DX","EFI","EMA","ER","ERI","EXP","FLOOR","FOSC","FRACTAL","HA","HMA","HT_DCPERIOD","HT_DCPHASE","HT_PHASOR","HT_SINE","HT_TRENDLINE","HT_TRENDMODE","IMI","KAMA","KC","KDJ","LINEARREG","LINEARREG_ANGLE","LINEARREG_INTERCEPT","LINEARREG_SLOPE","LN","LOG10","MA","MACD","MACDEXT","MACDFIX","MAMA","MARKETFI","MASSI","MAVP","MAX","MAXINDEX","MEDPRICE","MFI","MIDPOINT","MIDPRICE","MIN","MININDEX","MINMAX","MINMAXINDEX","MINUS_DI","MINUS_DM","MOM","MULT","NATR","NVI","OBV","PERCENTILE","PERCENTRANK","PLUS_DI","PLUS_DM","PPO","PVI","PVO","PVT","QSTICK","RMA","ROC","ROCP","ROCR","ROCR100","RSI","RVI","RVOL","SAR","SAREXT","SIN","SINH","SMA","SMI","SQRT","STDDEV","STOCH","STOCHF","STOCHRSI","SUB","SUM","SUPERTREND","T3","TAN","TANH","TEMA","TRANGE","TRIMA","TRIX","TSF","TSI","TYPPRICE","ULTOSC","VAR","VHF","VORTEX","VWAP","VWMA","WAD","WCLPRICE","WILLR","WMA","ZLEMA"] diff --git a/talib/_stream.pxi b/talib/_stream.pxi index b1575b2cc..988f27f2e 100644 --- a/talib/_stream.pxi +++ b/talib/_stream.pxi @@ -6,6 +6,40 @@ from _ta_lib cimport TA_RetCode np.import_array() # Initialize the NumPy C API +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_AC( np.ndarray high not None , np.ndarray low not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int signalperiod=-2**31 ): + """ AC(high, low[, fastperiod=?, slowperiod=?, signalperiod=?]) + + Accelerator/Decelerator Oscillator (Momentum Indicators) + + Inputs: + prices: ['high', 'low'] + Parameters: + fastperiod: 5 + slowperiod: 34 + signalperiod: 5 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* high_data + double* low_data + int outbegidx + int outnbelement + double outreal + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + length = check_length2(high, low) + outreal = NaN + retCode = lib.TA_AC( (length) - 1 , (length) - 1 , high_data , low_data , fastperiod , slowperiod , signalperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_AC", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_ACCBANDS( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): @@ -180,6 +214,38 @@ def stream_ADOSC( np.ndarray high not None , np.ndarray low not None , np.ndarra _ta_check_success("TA_ADOSC", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_ADR( np.ndarray high not None , np.ndarray low not None , int timeperiod=-2**31 ): + """ ADR(high, low[, timeperiod=?]) + + Average Day Range (Volatility Indicators) + + Inputs: + prices: ['high', 'low'] + Parameters: + timeperiod: 14 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* high_data + double* low_data + int outbegidx + int outnbelement + double outreal + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + length = check_length2(high, low) + outreal = NaN + retCode = lib.TA_ADR( (length) - 1 , (length) - 1 , high_data , low_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_ADR", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_ADX( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): @@ -252,7 +318,40 @@ def stream_ADXR( np.ndarray high not None , np.ndarray low not None , np.ndarray @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function -def stream_APO( np.ndarray real not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int matype=0 ): +def stream_AO( np.ndarray high not None , np.ndarray low not None , int fastperiod=-2**31 , int slowperiod=-2**31 ): + """ AO(high, low[, fastperiod=?, slowperiod=?]) + + Awesome Oscillator (Momentum Indicators) + + Inputs: + prices: ['high', 'low'] + Parameters: + fastperiod: 5 + slowperiod: 34 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* high_data + double* low_data + int outbegidx + int outnbelement + double outreal + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + length = check_length2(high, low) + outreal = NaN + retCode = lib.TA_AO( (length) - 1 , (length) - 1 , high_data , low_data , fastperiod , slowperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_AO", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_APO( np.ndarray real not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int matype=1 ): """ APO(real[, fastperiod=?, slowperiod=?, matype=?]) Absolute Price Oscillator (Momentum Indicators) @@ -262,7 +361,7 @@ def stream_APO( np.ndarray real not None , int fastperiod=-2**31 , int slowperio Parameters: fastperiod: 12 slowperiod: 26 - matype: 0 (Simple Moving Average) + matype: 1 (Exponential Moving Average) Outputs: real """ @@ -437,6 +536,35 @@ def stream_ATR( np.ndarray high not None , np.ndarray low not None , np.ndarray _ta_check_success("TA_ATR", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_AVGDEV( np.ndarray real not None , int timeperiod=-2**31 ): + """ AVGDEV(real[, timeperiod=?]) + + Average Deviation (Price Transform) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 14 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + length = real.shape[0] + outreal = NaN + retCode = lib.TA_AVGDEV( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_AVGDEV", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_AVGPRICE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): @@ -473,35 +601,6 @@ def stream_AVGPRICE( np.ndarray open not None , np.ndarray high not None , np.nd _ta_check_success("TA_AVGPRICE", retCode) return outreal -@wraparound(False) # turn off relative indexing from end of lists -@boundscheck(False) # turn off bounds-checking for entire function -def stream_AVGDEV( np.ndarray real not None , int timeperiod=-2**31 ): - """ AVGDEV(real[, timeperiod=?]) - - Average Deviation (Price Transform) - - Inputs: - real: (any ndarray) - Parameters: - timeperiod: 14 - Outputs: - real - """ - cdef: - np.npy_intp length - TA_RetCode retCode - double* real_data - int outbegidx - int outnbelement - double outreal - real = check_array(real) - real_data = real.data - length = real.shape[0] - outreal = NaN - retCode = lib.TA_AVGDEV( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) - _ta_check_success("TA_AVGDEV", retCode) - return outreal - @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_BBANDS( np.ndarray real not None , int timeperiod=-2**31 , double nbdevup=-4e37 , double nbdevdn=-4e37 , int matype=0 ): @@ -512,7 +611,7 @@ def stream_BBANDS( np.ndarray real not None , int timeperiod=-2**31 , double nbd Inputs: real: (any ndarray) Parameters: - timeperiod: 5 + timeperiod: 20 nbdevup: 2.0 nbdevdn: 2.0 matype: 0 (Simple Moving Average) @@ -757,7 +856,7 @@ def stream_CDL3INSIDE( np.ndarray open not None , np.ndarray high not None , np. def stream_CDL3LINESTRIKE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDL3LINESTRIKE(open, high, low, close) - Three-Line Strike (Pattern Recognition) + Three-Line Strike (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] @@ -2881,6 +2980,44 @@ def stream_CEIL( np.ndarray real not None ): _ta_check_success("TA_CEIL", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_CMF( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , np.ndarray volume not None , int timeperiod=-2**31 ): + """ CMF(high, low, close, volume[, timeperiod=?]) + + Chaikin Money Flow (Volume Indicators) + + Inputs: + prices: ['high', 'low', 'close', 'volume'] + Parameters: + timeperiod: 20 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* high_data + double* low_data + double* close_data + double* volume_data + int outbegidx + int outnbelement + double outreal + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + close = check_array(close) + close_data = close.data + volume = check_array(volume) + volume_data = volume.data + length = check_length4(high, low, close, volume) + outreal = NaN + retCode = lib.TA_CMF( (length) - 1 , (length) - 1 , high_data , low_data , close_data , volume_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_CMF", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CMO( np.ndarray real not None , int timeperiod=-2**31 ): @@ -2910,6 +3047,66 @@ def stream_CMO( np.ndarray real not None , int timeperiod=-2**31 ): _ta_check_success("TA_CMO", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_CMOU( np.ndarray real not None , int timeperiod=-2**31 ): + """ CMOU(real[, timeperiod=?]) + + Chande Momentum Oscillator (Unsmoothed) (Momentum Indicators) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 14 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + length = real.shape[0] + outreal = NaN + retCode = lib.TA_CMOU( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_CMOU", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_COPPOCK( np.ndarray real not None , int wmaperiod=-2**31 , int roc1period=-2**31 , int roc2period=-2**31 ): + """ COPPOCK(real[, wmaperiod=?, roc1period=?, roc2period=?]) + + Coppock Curve (Momentum Indicators) + + Inputs: + real: (any ndarray) + Parameters: + wmaperiod: 10 + roc1period: 11 + roc2period: 14 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + length = real.shape[0] + outreal = NaN + retCode = lib.TA_COPPOCK( (length) - 1 , (length) - 1 , real_data , wmaperiod , roc1period , roc2period , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_COPPOCK", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CORREL( np.ndarray real0 not None , np.ndarray real1 not None , int timeperiod=-2**31 ): @@ -2999,15 +3196,13 @@ def stream_COSH( np.ndarray real not None ): @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function -def stream_DEMA( np.ndarray real not None , int timeperiod=-2**31 ): - """ DEMA(real[, timeperiod=?]) +def stream_CUMSUM( np.ndarray real not None ): + """ CUMSUM(real) - Double Exponential Moving Average (Overlap Studies) + Cumulative Sum (Math Operators) Inputs: real: (any ndarray) - Parameters: - timeperiod: 30 Outputs: real """ @@ -3022,47 +3217,176 @@ def stream_DEMA( np.ndarray real not None , int timeperiod=-2**31 ): real_data = real.data length = real.shape[0] outreal = NaN - retCode = lib.TA_DEMA( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) - _ta_check_success("TA_DEMA", retCode) + retCode = lib.TA_CUMSUM( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_CUMSUM", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function -def stream_DIV( np.ndarray real0 not None , np.ndarray real1 not None ): - """ DIV(real0, real1) +def stream_CVI( np.ndarray high not None , np.ndarray low not None , int timeperiod=-2**31 , int rocperiod=-2**31 ): + """ CVI(high, low[, timeperiod=?, rocperiod=?]) - Vector Arithmetic Div (Math Operators) + Chaikin's Volatility (Volatility Indicators) Inputs: - real0: (any ndarray) - real1: (any ndarray) + prices: ['high', 'low'] + Parameters: + timeperiod: 10 + rocperiod: 10 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode - double* real0_data - double* real1_data + double* high_data + double* low_data int outbegidx int outnbelement double outreal - real0 = check_array(real0) - real0_data = real0.data - real1 = check_array(real1) - real1_data = real1.data - length = check_length2(real0, real1) + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + length = check_length2(high, low) outreal = NaN - retCode = lib.TA_DIV( (length) - 1 , (length) - 1 , real0_data , real1_data , &outbegidx , &outnbelement , &outreal ) - _ta_check_success("TA_DIV", retCode) + retCode = lib.TA_CVI( (length) - 1 , (length) - 1 , high_data , low_data , timeperiod , rocperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_CVI", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function -def stream_DX( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): - """ DX(high, low, close[, timeperiod=?]) +def stream_DEMA( np.ndarray real not None , int timeperiod=-2**31 ): + """ DEMA(real[, timeperiod=?]) - Directional Movement Index (Momentum Indicators) + Double Exponential Moving Average (Overlap Studies) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 30 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + length = real.shape[0] + outreal = NaN + retCode = lib.TA_DEMA( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_DEMA", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_DIV( np.ndarray real0 not None , np.ndarray real1 not None ): + """ DIV(real0, real1) + + Vector Arithmetic Div (Math Operators) + + Inputs: + real0: (any ndarray) + real1: (any ndarray) + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real0_data + double* real1_data + int outbegidx + int outnbelement + double outreal + real0 = check_array(real0) + real0_data = real0.data + real1 = check_array(real1) + real1_data = real1.data + length = check_length2(real0, real1) + outreal = NaN + retCode = lib.TA_DIV( (length) - 1 , (length) - 1 , real0_data , real1_data , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_DIV", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_DONCHIAN( np.ndarray high not None , np.ndarray low not None , int timeperiod=-2**31 ): + """ DONCHIAN(high, low[, timeperiod=?]) + + Donchian Channels (Overlap Studies) + + Inputs: + prices: ['high', 'low'] + Parameters: + timeperiod: 20 + Outputs: + upperband + middleband + lowerband + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* high_data + double* low_data + int outbegidx + int outnbelement + double outrealupperband + double outrealmiddleband + double outreallowerband + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + length = check_length2(high, low) + outrealupperband = NaN + outrealmiddleband = NaN + outreallowerband = NaN + retCode = lib.TA_DONCHIAN( (length) - 1 , (length) - 1 , high_data , low_data , timeperiod , &outbegidx , &outnbelement , &outrealupperband , &outrealmiddleband , &outreallowerband ) + _ta_check_success("TA_DONCHIAN", retCode) + return outrealupperband , outrealmiddleband , outreallowerband + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_DPO( np.ndarray real not None , int timeperiod=-2**31 ): + """ DPO(real[, timeperiod=?]) + + Detrended Price Oscillator (Momentum Indicators) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 20 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + length = real.shape[0] + outreal = NaN + retCode = lib.TA_DPO( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_DPO", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_DX( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): + """ DX(high, low, close[, timeperiod=?]) + + Directional Movement Index (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] @@ -3092,6 +3416,38 @@ def stream_DX( np.ndarray high not None , np.ndarray low not None , np.ndarray c _ta_check_success("TA_DX", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_EFI( np.ndarray close not None , np.ndarray volume not None , int timeperiod=-2**31 ): + """ EFI(close, volume[, timeperiod=?]) + + Elder's Force Index (Volume Indicators) + + Inputs: + prices: ['close', 'volume'] + Parameters: + timeperiod: 13 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* close_data + double* volume_data + int outbegidx + int outnbelement + double outreal + close = check_array(close) + close_data = close.data + volume = check_array(volume) + volume_data = volume.data + length = check_length2(close, volume) + outreal = NaN + retCode = lib.TA_EFI( (length) - 1 , (length) - 1 , close_data , volume_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_EFI", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_EMA( np.ndarray real not None , int timeperiod=-2**31 ): @@ -3121,6 +3477,73 @@ def stream_EMA( np.ndarray real not None , int timeperiod=-2**31 ): _ta_check_success("TA_EMA", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_ER( np.ndarray real not None , int timeperiod=-2**31 ): + """ ER(real[, timeperiod=?]) + + Kaufman Efficiency Ratio (Momentum Indicators) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 10 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + length = real.shape[0] + outreal = NaN + retCode = lib.TA_ER( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_ER", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_ERI( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): + """ ERI(high, low, close[, timeperiod=?]) + + Elder Ray Index (Bull Power / Bear Power) (Momentum Indicators) + + Inputs: + prices: ['high', 'low', 'close'] + Parameters: + timeperiod: 13 + Outputs: + bullpower + bearpower + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* high_data + double* low_data + double* close_data + int outbegidx + int outnbelement + double outbullpower + double outbearpower + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + close = check_array(close) + close_data = close.data + length = check_length3(high, low, close) + outbullpower = NaN + outbearpower = NaN + retCode = lib.TA_ERI( (length) - 1 , (length) - 1 , high_data , low_data , close_data , timeperiod , &outbegidx , &outnbelement , &outbullpower , &outbearpower ) + _ta_check_success("TA_ERI", retCode) + return outbullpower , outbearpower + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_EXP( np.ndarray real not None ): @@ -3175,6 +3598,145 @@ def stream_FLOOR( np.ndarray real not None ): _ta_check_success("TA_FLOOR", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_FOSC( np.ndarray real not None , int timeperiod=-2**31 ): + """ FOSC(real[, timeperiod=?]) + + Forecast Oscillator (Momentum Indicators) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 5 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + length = real.shape[0] + outreal = NaN + retCode = lib.TA_FOSC( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_FOSC", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_FRACTAL( np.ndarray high not None , np.ndarray low not None , int leftbars=-2**31 , int rightbars=-2**31 ): + """ FRACTAL(high, low[, leftbars=?, rightbars=?]) + + Williams Fractal (Momentum Indicators) + + Inputs: + prices: ['high', 'low'] + Parameters: + leftbars: 2 + rightbars: 2 + Outputs: + swinghigh + swinglow + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* high_data + double* low_data + int outbegidx + int outnbelement + int outswinghigh + int outswinglow + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + length = check_length2(high, low) + outswinghigh = 0 + outswinglow = 0 + retCode = lib.TA_FRACTAL( (length) - 1 , (length) - 1 , high_data , low_data , leftbars , rightbars , &outbegidx , &outnbelement , &outswinghigh , &outswinglow ) + _ta_check_success("TA_FRACTAL", retCode) + return outswinghigh , outswinglow + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_HA( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): + """ HA(open, high, low, close) + + Heikin-Ashi Candles (Price Transform) + + Inputs: + prices: ['open', 'high', 'low', 'close'] + Outputs: + haopen + hahigh + halow + haclose + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* open_data + double* high_data + double* low_data + double* close_data + int outbegidx + int outnbelement + double outhaopen + double outhahigh + double outhalow + double outhaclose + open = check_array(open) + open_data = open.data + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + close = check_array(close) + close_data = close.data + length = check_length4(open, high, low, close) + outhaopen = NaN + outhahigh = NaN + outhalow = NaN + outhaclose = NaN + retCode = lib.TA_HA( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outhaopen , &outhahigh , &outhalow , &outhaclose ) + _ta_check_success("TA_HA", retCode) + return outhaopen , outhahigh , outhalow , outhaclose + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_HMA( np.ndarray real not None , int timeperiod=-2**31 ): + """ HMA(real[, timeperiod=?]) + + Hull Moving Average (Overlap Studies) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 20 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + length = real.shape[0] + outreal = NaN + retCode = lib.TA_HMA( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_HMA", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_HT_DCPERIOD( np.ndarray real not None ): @@ -3326,7 +3888,7 @@ def stream_HT_TRENDMODE( np.ndarray real not None ): Inputs: real: (any ndarray) Outputs: - integer (values are -100, 0 or 100) + integer """ cdef: np.npy_intp length @@ -3404,6 +3966,94 @@ def stream_KAMA( np.ndarray real not None , int timeperiod=-2**31 ): _ta_check_success("TA_KAMA", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_KC( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 , int atrperiod=-2**31 , double nbdev=-4e37 ): + """ KC(high, low, close[, timeperiod=?, atrperiod=?, nbdev=?]) + + Keltner Channels (Overlap Studies) + + Inputs: + prices: ['high', 'low', 'close'] + Parameters: + timeperiod: 20 + atrperiod: 10 + nbdev: 2.0 + Outputs: + upperband + middleband + lowerband + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* high_data + double* low_data + double* close_data + int outbegidx + int outnbelement + double outrealupperband + double outrealmiddleband + double outreallowerband + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + close = check_array(close) + close_data = close.data + length = check_length3(high, low, close) + outrealupperband = NaN + outrealmiddleband = NaN + outreallowerband = NaN + retCode = lib.TA_KC( (length) - 1 , (length) - 1 , high_data , low_data , close_data , timeperiod , atrperiod , nbdev , &outbegidx , &outnbelement , &outrealupperband , &outrealmiddleband , &outreallowerband ) + _ta_check_success("TA_KC", retCode) + return outrealupperband , outrealmiddleband , outreallowerband + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_KDJ( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int fastk_period=-2**31 , int slowk_period=-2**31 , int slowk_matype=13 , int slowd_period=-2**31 , int slowd_matype=13 ): + """ KDJ(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?]) + + KDJ Stochastic (Momentum Indicators) + + Inputs: + prices: ['high', 'low', 'close'] + Parameters: + fastk_period: 9 + slowk_period: 3 + slowk_matype: 13 (Wilder's Smoothed Moving Average) + slowd_period: 3 + slowd_matype: 13 (Wilder's Smoothed Moving Average) + Outputs: + k + d + j + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* high_data + double* low_data + double* close_data + int outbegidx + int outnbelement + double outk + double outd + double outj + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + close = check_array(close) + close_data = close.data + length = check_length3(high, low, close) + outk = NaN + outd = NaN + outj = NaN + retCode = lib.TA_KDJ( (length) - 1 , (length) - 1 , high_data , low_data , close_data , fastk_period , slowk_period , slowk_matype , slowd_period , slowd_matype , &outbegidx , &outnbelement , &outk , &outd , &outj ) + _ta_check_success("TA_KDJ", retCode) + return outk , outd , outj + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_LINEARREG( np.ndarray real not None , int timeperiod=-2**31 ): @@ -3652,11 +4302,11 @@ def stream_MACDEXT( np.ndarray real not None , int fastperiod=-2**31 , int fastm real: (any ndarray) Parameters: fastperiod: 12 - fastmatype: 0 + fastmatype: 0 (Simple Moving Average) slowperiod: 26 - slowmatype: 0 + slowmatype: 0 (Simple Moving Average) signalperiod: 9 - signalmatype: 0 + signalmatype: 0 (Simple Moving Average) Outputs: macd macdsignal @@ -3749,6 +4399,72 @@ def stream_MAMA( np.ndarray real not None , double fastlimit=-4e37 , double slow _ta_check_success("TA_MAMA", retCode) return outmama , outfama +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_MARKETFI( np.ndarray high not None , np.ndarray low not None , np.ndarray volume not None ): + """ MARKETFI(high, low, volume) + + Market Facilitation Index (Volume Indicators) + + Inputs: + prices: ['high', 'low', 'volume'] + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* high_data + double* low_data + double* volume_data + int outbegidx + int outnbelement + double outreal + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + volume = check_array(volume) + volume_data = volume.data + length = check_length3(high, low, volume) + outreal = NaN + retCode = lib.TA_MARKETFI( (length) - 1 , (length) - 1 , high_data , low_data , volume_data , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_MARKETFI", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_MASSI( np.ndarray high not None , np.ndarray low not None , int fastperiod=-2**31 , int slowperiod=-2**31 ): + """ MASSI(high, low[, fastperiod=?, slowperiod=?]) + + Mass Index (Volatility Indicators) + + Inputs: + prices: ['high', 'low'] + Parameters: + fastperiod: 9 + slowperiod: 25 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* high_data + double* low_data + int outbegidx + int outnbelement + double outreal + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + length = check_length2(high, low) + outreal = NaN + retCode = lib.TA_MASSI( (length) - 1 , (length) - 1 , high_data , low_data , fastperiod , slowperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_MASSI", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MAVP( np.ndarray real not None , np.ndarray periods not None , int minperiod=-2**31 , int maxperiod=-2**31 , int matype=0 ): @@ -3825,7 +4541,7 @@ def stream_MAXINDEX( np.ndarray real not None , int timeperiod=-2**31 ): Parameters: timeperiod: 30 Outputs: - integer (values are -100, 0 or 100) + integer """ cdef: np.npy_intp length @@ -4012,7 +4728,7 @@ def stream_MININDEX( np.ndarray real not None , int timeperiod=-2**31 ): Parameters: timeperiod: 30 Outputs: - integer (values are -100, 0 or 100) + integer """ cdef: np.npy_intp length @@ -4255,6 +4971,36 @@ def stream_NATR( np.ndarray high not None , np.ndarray low not None , np.ndarray _ta_check_success("TA_NATR", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_NVI( np.ndarray close not None , np.ndarray volume not None ): + """ NVI(close, volume) + + Negative Volume Index (Volume Indicators) + + Inputs: + prices: ['close', 'volume'] + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* close_data + double* volume_data + int outbegidx + int outnbelement + double outreal + close = check_array(close) + close_data = close.data + volume = check_array(volume) + volume_data = volume.data + length = check_length2(close, volume) + outreal = NaN + retCode = lib.TA_NVI( (length) - 1 , (length) - 1 , close_data , volume_data , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_NVI", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_OBV( np.ndarray real not None , np.ndarray volume not None ): @@ -4286,6 +5032,65 @@ def stream_OBV( np.ndarray real not None , np.ndarray volume not None ): _ta_check_success("TA_OBV", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_PERCENTILE( np.ndarray real not None , int timeperiod=-2**31 , double percentile=50.0 ): + """ PERCENTILE(real[, timeperiod=?, percentile=?]) + + Percentile (nearest rank) (Statistic Functions) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 30 + percentile: 50.0 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + length = real.shape[0] + outreal = NaN + retCode = lib.TA_PERCENTILE( (length) - 1 , (length) - 1 , real_data , timeperiod , percentile , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_PERCENTILE", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_PERCENTRANK( np.ndarray real not None , int timeperiod=-2**31 ): + """ PERCENTRANK(real[, timeperiod=?]) + + Percent Rank (Statistic Functions) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 100 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + length = real.shape[0] + outreal = NaN + retCode = lib.TA_PERCENTRANK( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_PERCENTRANK", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_PLUS_DI( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): @@ -4355,7 +5160,7 @@ def stream_PLUS_DM( np.ndarray high not None , np.ndarray low not None , int tim @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function -def stream_PPO( np.ndarray real not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int matype=0 ): +def stream_PPO( np.ndarray real not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int matype=1 ): """ PPO(real[, fastperiod=?, slowperiod=?, matype=?]) Percentage Price Oscillator (Momentum Indicators) @@ -4365,7 +5170,7 @@ def stream_PPO( np.ndarray real not None , int fastperiod=-2**31 , int slowperio Parameters: fastperiod: 12 slowperiod: 26 - matype: 0 (Simple Moving Average) + matype: 1 (Exponential Moving Average) Outputs: real """ @@ -4384,6 +5189,158 @@ def stream_PPO( np.ndarray real not None , int fastperiod=-2**31 , int slowperio _ta_check_success("TA_PPO", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_PVI( np.ndarray close not None , np.ndarray volume not None ): + """ PVI(close, volume) + + Positive Volume Index (Volume Indicators) + + Inputs: + prices: ['close', 'volume'] + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* close_data + double* volume_data + int outbegidx + int outnbelement + double outreal + close = check_array(close) + close_data = close.data + volume = check_array(volume) + volume_data = volume.data + length = check_length2(close, volume) + outreal = NaN + retCode = lib.TA_PVI( (length) - 1 , (length) - 1 , close_data , volume_data , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_PVI", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_PVO( np.ndarray volume not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int matype=1 ): + """ PVO(volume[, fastperiod=?, slowperiod=?, matype=?]) + + Percentage Volume Oscillator (Volume Indicators) + + Inputs: + prices: ['volume'] + Parameters: + fastperiod: 12 + slowperiod: 26 + matype: 1 (Exponential Moving Average) + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* volume_data + int outbegidx + int outnbelement + double outreal + volume = check_array(volume) + volume_data = volume.data + length = volume.shape[0] + outreal = NaN + retCode = lib.TA_PVO( (length) - 1 , (length) - 1 , volume_data , fastperiod , slowperiod , matype , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_PVO", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_PVT( np.ndarray close not None , np.ndarray volume not None ): + """ PVT(close, volume) + + Price Volume Trend (Volume Indicators) + + Inputs: + prices: ['close', 'volume'] + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* close_data + double* volume_data + int outbegidx + int outnbelement + double outreal + close = check_array(close) + close_data = close.data + volume = check_array(volume) + volume_data = volume.data + length = check_length2(close, volume) + outreal = NaN + retCode = lib.TA_PVT( (length) - 1 , (length) - 1 , close_data , volume_data , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_PVT", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_QSTICK( np.ndarray open not None , np.ndarray close not None , int timeperiod=-2**31 ): + """ QSTICK(open, close[, timeperiod=?]) + + Qstick (Momentum Indicators) + + Inputs: + prices: ['open', 'close'] + Parameters: + timeperiod: 10 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* open_data + double* close_data + int outbegidx + int outnbelement + double outreal + open = check_array(open) + open_data = open.data + close = check_array(close) + close_data = close.data + length = check_length2(open, close) + outreal = NaN + retCode = lib.TA_QSTICK( (length) - 1 , (length) - 1 , open_data , close_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_QSTICK", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_RMA( np.ndarray real not None , int timeperiod=-2**31 ): + """ RMA(real[, timeperiod=?]) + + Wilder's Smoothed Moving Average (Overlap Studies) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 30 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + length = real.shape[0] + outreal = NaN + retCode = lib.TA_RMA( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_RMA", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_ROC( np.ndarray real not None , int timeperiod=-2**31 ): @@ -4502,31 +5459,90 @@ def stream_ROCR100( np.ndarray real not None , int timeperiod=-2**31 ): @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function -def stream_RSI( np.ndarray real not None , int timeperiod=-2**31 ): - """ RSI(real[, timeperiod=?]) +def stream_RSI( np.ndarray real not None , int timeperiod=-2**31 ): + """ RSI(real[, timeperiod=?]) + + Relative Strength Index (Momentum Indicators) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 14 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + length = real.shape[0] + outreal = NaN + retCode = lib.TA_RSI( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_RSI", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_RVI( np.ndarray real not None , int timeperiod=-2**31 , int stddevperiod=-2**31 ): + """ RVI(real[, timeperiod=?, stddevperiod=?]) + + Relative Volatility Index (Volatility Indicators) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 14 + stddevperiod: 10 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + length = real.shape[0] + outreal = NaN + retCode = lib.TA_RVI( (length) - 1 , (length) - 1 , real_data , timeperiod , stddevperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_RVI", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_RVOL( np.ndarray volume not None , int timeperiod=-2**31 ): + """ RVOL(volume[, timeperiod=?]) - Relative Strength Index (Momentum Indicators) + Relative Volume (Volume Indicators) Inputs: - real: (any ndarray) + prices: ['volume'] Parameters: - timeperiod: 14 + timeperiod: 20 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode - double* real_data + double* volume_data int outbegidx int outnbelement double outreal - real = check_array(real) - real_data = real.data - length = real.shape[0] + volume = check_array(volume) + volume_data = volume.data + length = volume.shape[0] outreal = NaN - retCode = lib.TA_RSI( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) - _ta_check_success("TA_RSI", retCode) + retCode = lib.TA_RVOL( (length) - 1 , (length) - 1 , volume_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_RVOL", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @@ -4684,6 +5700,47 @@ def stream_SMA( np.ndarray real not None , int timeperiod=-2**31 ): _ta_check_success("TA_SMA", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_SMI( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 , int fastperiod=-2**31 , int slowperiod=-2**31 , int signalperiod=-2**31 ): + """ SMI(high, low, close[, timeperiod=?, fastperiod=?, slowperiod=?, signalperiod=?]) + + Stochastic Momentum Index (Momentum Indicators) + + Inputs: + prices: ['high', 'low', 'close'] + Parameters: + timeperiod: 13 + fastperiod: 2 + slowperiod: 25 + signalperiod: 9 + Outputs: + smi + smisignal + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* high_data + double* low_data + double* close_data + int outbegidx + int outnbelement + double outsmi + double outsmisignal + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + close = check_array(close) + close_data = close.data + length = check_length3(high, low, close) + outsmi = NaN + outsmisignal = NaN + retCode = lib.TA_SMI( (length) - 1 , (length) - 1 , high_data , low_data , close_data , timeperiod , fastperiod , slowperiod , signalperiod , &outbegidx , &outnbelement , &outsmi , &outsmisignal ) + _ta_check_success("TA_SMI", retCode) + return outsmi , outsmisignal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_SQRT( np.ndarray real not None ): @@ -4753,9 +5810,9 @@ def stream_STOCH( np.ndarray high not None , np.ndarray low not None , np.ndarra Parameters: fastk_period: 5 slowk_period: 3 - slowk_matype: 0 + slowk_matype: 0 (Simple Moving Average) slowd_period: 3 - slowd_matype: 0 + slowd_matype: 0 (Simple Moving Average) Outputs: slowk slowd @@ -4795,7 +5852,7 @@ def stream_STOCHF( np.ndarray high not None , np.ndarray low not None , np.ndarr Parameters: fastk_period: 5 fastd_period: 3 - fastd_matype: 0 + fastd_matype: 0 (Simple Moving Average) Outputs: fastk fastd @@ -4836,7 +5893,7 @@ def stream_STOCHRSI( np.ndarray real not None , int timeperiod=-2**31 , int fast timeperiod: 14 fastk_period: 5 fastd_period: 3 - fastd_matype: 0 + fastd_matype: 0 (Simple Moving Average) Outputs: fastk fastd @@ -4918,6 +5975,45 @@ def stream_SUM( np.ndarray real not None , int timeperiod=-2**31 ): _ta_check_success("TA_SUM", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_SUPERTREND( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 , double multiplier=3.0 ): + """ SUPERTREND(high, low, close[, timeperiod=?, multiplier=?]) + + SuperTrend (Overlap Studies) + + Inputs: + prices: ['high', 'low', 'close'] + Parameters: + timeperiod: 10 + multiplier: 3.0 + Outputs: + real + integer + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* high_data + double* low_data + double* close_data + int outbegidx + int outnbelement + double outreal + int outinteger + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + close = check_array(close) + close_data = close.data + length = check_length3(high, low, close) + outreal = NaN + outinteger = 0 + retCode = lib.TA_SUPERTREND( (length) - 1 , (length) - 1 , high_data , low_data , close_data , timeperiod , multiplier , &outbegidx , &outnbelement , &outreal , &outinteger ) + _ta_check_success("TA_SUPERTREND", retCode) + return outreal , outinteger + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_T3( np.ndarray real not None , int timeperiod=-2**31 , double vfactor=-4e37 ): @@ -5151,6 +6247,36 @@ def stream_TSF( np.ndarray real not None , int timeperiod=-2**31 ): _ta_check_success("TA_TSF", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_TSI( np.ndarray real not None , int firstperiod=-2**31 , int secondperiod=-2**31 ): + """ TSI(real[, firstperiod=?, secondperiod=?]) + + True Strength Index (Momentum Indicators) + + Inputs: + real: (any ndarray) + Parameters: + firstperiod: 25 + secondperiod: 13 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + length = real.shape[0] + outreal = NaN + retCode = lib.TA_TSI( (length) - 1 , (length) - 1 , real_data , firstperiod , secondperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_TSI", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_TYPPRICE( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): @@ -5251,6 +6377,175 @@ def stream_VAR( np.ndarray real not None , int timeperiod=-2**31 , double nbdev= _ta_check_success("TA_VAR", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_VHF( np.ndarray real not None , int timeperiod=-2**31 ): + """ VHF(real[, timeperiod=?]) + + Vertical Horizontal Filter (Momentum Indicators) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 28 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + length = real.shape[0] + outreal = NaN + retCode = lib.TA_VHF( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_VHF", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_VORTEX( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): + """ VORTEX(high, low, close[, timeperiod=?]) + + Vortex Indicator (Momentum Indicators) + + Inputs: + prices: ['high', 'low', 'close'] + Parameters: + timeperiod: 14 + Outputs: + plusvi + minusvi + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* high_data + double* low_data + double* close_data + int outbegidx + int outnbelement + double outplusvi + double outminusvi + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + close = check_array(close) + close_data = close.data + length = check_length3(high, low, close) + outplusvi = NaN + outminusvi = NaN + retCode = lib.TA_VORTEX( (length) - 1 , (length) - 1 , high_data , low_data , close_data , timeperiod , &outbegidx , &outnbelement , &outplusvi , &outminusvi ) + _ta_check_success("TA_VORTEX", retCode) + return outplusvi , outminusvi + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_VWAP( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , np.ndarray volume not None ): + """ VWAP(high, low, close, volume) + + Volume Weighted Average Price (Volume Indicators) + + Inputs: + prices: ['high', 'low', 'close', 'volume'] + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* high_data + double* low_data + double* close_data + double* volume_data + int outbegidx + int outnbelement + double outreal + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + close = check_array(close) + close_data = close.data + volume = check_array(volume) + volume_data = volume.data + length = check_length4(high, low, close, volume) + outreal = NaN + retCode = lib.TA_VWAP( (length) - 1 , (length) - 1 , high_data , low_data , close_data , volume_data , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_VWAP", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_VWMA( np.ndarray real not None , np.ndarray volume not None , int timeperiod=-2**31 ): + """ VWMA(real, volume[, timeperiod=?]) + + Volume Weighted Moving Average (Overlap Studies) + + Inputs: + real: (any ndarray) + prices: ['volume'] + Parameters: + timeperiod: 30 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + double* volume_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + volume = check_array(volume) + volume_data = volume.data + length = check_length2(real, volume) + outreal = NaN + retCode = lib.TA_VWMA( (length) - 1 , (length) - 1 , real_data , volume_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_VWMA", retCode) + return outreal + +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_WAD( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): + """ WAD(high, low, close) + + Williams' Accumulation/Distribution (Momentum Indicators) + + Inputs: + prices: ['high', 'low', 'close'] + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* high_data + double* low_data + double* close_data + int outbegidx + int outnbelement + double outreal + high = check_array(high) + high_data = high.data + low = check_array(low) + low_data = low.data + close = check_array(close) + close_data = close.data + length = check_length3(high, low, close) + outreal = NaN + retCode = lib.TA_WAD( (length) - 1 , (length) - 1 , high_data , low_data , close_data , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_WAD", retCode) + return outreal + @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_WCLPRICE( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): @@ -5348,3 +6643,32 @@ def stream_WMA( np.ndarray real not None , int timeperiod=-2**31 ): _ta_check_success("TA_WMA", retCode) return outreal +@wraparound(False) # turn off relative indexing from end of lists +@boundscheck(False) # turn off bounds-checking for entire function +def stream_ZLEMA( np.ndarray real not None , int timeperiod=-2**31 ): + """ ZLEMA(real[, timeperiod=?]) + + Zero-Lag Exponential Moving Average (Overlap Studies) + + Inputs: + real: (any ndarray) + Parameters: + timeperiod: 30 + Outputs: + real + """ + cdef: + np.npy_intp length + TA_RetCode retCode + double* real_data + int outbegidx + int outnbelement + double outreal + real = check_array(real) + real_data = real.data + length = real.shape[0] + outreal = NaN + retCode = lib.TA_ZLEMA( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) + _ta_check_success("TA_ZLEMA", retCode) + return outreal + diff --git a/talib/_ta_lib.pxd b/talib/_ta_lib.pxd index 03e015e6c..ede95b0ff 100644 --- a/talib/_ta_lib.pxd +++ b/talib/_ta_lib.pxd @@ -20,6 +20,7 @@ cdef extern from "ta-lib/ta_defs.h": const TA_RetCode TA_INVALID_LIST_TYPE = 14 const TA_RetCode TA_BAD_OBJECT = 15 const TA_RetCode TA_NOT_SUPPORTED = 16 + const TA_RetCode TA_INSUFFICIENT_HISTORY = 17 const TA_RetCode TA_INTERNAL_ERROR = 5000 const TA_RetCode TA_UNKNOWN_ERR = 0xffff @@ -37,6 +38,11 @@ cdef extern from "ta-lib/ta_defs.h": const TA_MAType TA_MAType_KAMA = 6 const TA_MAType TA_MAType_MAMA = 7 const TA_MAType TA_MAType_T3 = 8 + const TA_MAType TA_MAType_HMA = 9 + const TA_MAType TA_MAType_DISABLED = 10 + const TA_MAType TA_MAType_DEFAULT = 11 + const TA_MAType TA_MAType_ZLEMA = 12 + const TA_MAType TA_MAType_RMA = 13 ctypedef int TA_FuncUnstId # No values here on purpose. Cython takes the value of a `cdef extern` @@ -63,6 +69,9 @@ cdef extern from "ta-lib/ta_defs.h": const TA_FuncUnstId TA_FUNC_UNST_PLUS_DM const TA_FuncUnstId TA_FUNC_UNST_RSI const TA_FuncUnstId TA_FUNC_UNST_T3 + const TA_FuncUnstId TA_FUNC_UNST_RMA + const TA_FuncUnstId TA_FUNC_UNST_HA + const TA_FuncUnstId TA_FUNC_UNST_RVI const TA_FuncUnstId TA_FUNC_UNST_ALL ctypedef int TA_RangeType @@ -193,6 +202,8 @@ cdef extern from "ta-lib/ta_abstract.h": char* TA_FunctionDescriptionXML() cdef extern from "ta-lib/ta_func.h": + TA_RetCode TA_AC(int startIdx, int endIdx, const double inHigh[], const double inLow[], int optInFastPeriod, int optInSlowPeriod, int optInSignalPeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_AC_Lookback(int optInFastPeriod, int optInSlowPeriod, int optInSignalPeriod) TA_RetCode TA_ACCBANDS(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outRealUpperBand[], double outRealMiddleBand[], double outRealLowerBand[]) int TA_ACCBANDS_Lookback(int optInTimePeriod) TA_RetCode TA_ACOS(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) @@ -203,10 +214,14 @@ cdef extern from "ta-lib/ta_func.h": int TA_ADD_Lookback() TA_RetCode TA_ADOSC(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], const double inVolume[], int optInFastPeriod, int optInSlowPeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_ADOSC_Lookback(int optInFastPeriod, int optInSlowPeriod) + TA_RetCode TA_ADR(int startIdx, int endIdx, const double inHigh[], const double inLow[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_ADR_Lookback(int optInTimePeriod) TA_RetCode TA_ADX(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_ADX_Lookback(int optInTimePeriod) TA_RetCode TA_ADXR(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_ADXR_Lookback(int optInTimePeriod) + TA_RetCode TA_AO(int startIdx, int endIdx, const double inHigh[], const double inLow[], int optInFastPeriod, int optInSlowPeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_AO_Lookback(int optInFastPeriod, int optInSlowPeriod) TA_RetCode TA_APO(int startIdx, int endIdx, const double inReal[], int optInFastPeriod, int optInSlowPeriod, TA_MAType optInMAType, int *outBegIdx, int *outNBElement, double outReal[]) int TA_APO_Lookback(int optInFastPeriod, int optInSlowPeriod, TA_MAType optInMAType) TA_RetCode TA_AROON(int startIdx, int endIdx, const double inHigh[], const double inLow[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outAroonDown[], double outAroonUp[]) @@ -219,10 +234,10 @@ cdef extern from "ta-lib/ta_func.h": int TA_ATAN_Lookback() TA_RetCode TA_ATR(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_ATR_Lookback(int optInTimePeriod) - TA_RetCode TA_AVGPRICE(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, double outReal[]) - int TA_AVGPRICE_Lookback() TA_RetCode TA_AVGDEV(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_AVGDEV_Lookback(int optInTimePeriod) + TA_RetCode TA_AVGPRICE(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, double outReal[]) + int TA_AVGPRICE_Lookback() TA_RetCode TA_BBANDS(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, double optInNbDevUp, double optInNbDevDn, TA_MAType optInMAType, int *outBegIdx, int *outNBElement, double outRealUpperBand[], double outRealMiddleBand[], double outRealLowerBand[]) int TA_BBANDS_Lookback(int optInTimePeriod, double optInNbDevUp, double optInNbDevDn, TA_MAType optInMAType) TA_RetCode TA_BETA(int startIdx, int endIdx, const double inReal0[], const double inReal1[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) @@ -355,26 +370,54 @@ cdef extern from "ta-lib/ta_func.h": int TA_CDLXSIDEGAP3METHODS_Lookback() TA_RetCode TA_CEIL(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_CEIL_Lookback() + TA_RetCode TA_CMF(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], const double inVolume[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_CMF_Lookback(int optInTimePeriod) TA_RetCode TA_CMO(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_CMO_Lookback(int optInTimePeriod) + TA_RetCode TA_CMOU(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_CMOU_Lookback(int optInTimePeriod) + TA_RetCode TA_COPPOCK(int startIdx, int endIdx, const double inReal[], int optInWMAPeriod, int optInROC1Period, int optInROC2Period, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_COPPOCK_Lookback(int optInWMAPeriod, int optInROC1Period, int optInROC2Period) TA_RetCode TA_CORREL(int startIdx, int endIdx, const double inReal0[], const double inReal1[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_CORREL_Lookback(int optInTimePeriod) TA_RetCode TA_COS(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_COS_Lookback() TA_RetCode TA_COSH(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_COSH_Lookback() + TA_RetCode TA_CUMSUM(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) + int TA_CUMSUM_Lookback() + TA_RetCode TA_CVI(int startIdx, int endIdx, const double inHigh[], const double inLow[], int optInTimePeriod, int optInROCPeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_CVI_Lookback(int optInTimePeriod, int optInROCPeriod) TA_RetCode TA_DEMA(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_DEMA_Lookback(int optInTimePeriod) TA_RetCode TA_DIV(int startIdx, int endIdx, const double inReal0[], const double inReal1[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_DIV_Lookback() + TA_RetCode TA_DONCHIAN(int startIdx, int endIdx, const double inHigh[], const double inLow[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outRealUpperBand[], double outRealMiddleBand[], double outRealLowerBand[]) + int TA_DONCHIAN_Lookback(int optInTimePeriod) + TA_RetCode TA_DPO(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_DPO_Lookback(int optInTimePeriod) TA_RetCode TA_DX(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_DX_Lookback(int optInTimePeriod) + TA_RetCode TA_EFI(int startIdx, int endIdx, const double inClose[], const double inVolume[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_EFI_Lookback(int optInTimePeriod) TA_RetCode TA_EMA(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_EMA_Lookback(int optInTimePeriod) + TA_RetCode TA_ER(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_ER_Lookback(int optInTimePeriod) + TA_RetCode TA_ERI(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outBullPower[], double outBearPower[]) + int TA_ERI_Lookback(int optInTimePeriod) TA_RetCode TA_EXP(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_EXP_Lookback() TA_RetCode TA_FLOOR(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_FLOOR_Lookback() + TA_RetCode TA_FOSC(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_FOSC_Lookback(int optInTimePeriod) + TA_RetCode TA_FRACTAL(int startIdx, int endIdx, const double inHigh[], const double inLow[], int optInLeftBars, int optInRightBars, int *outBegIdx, int *outNBElement, int outSwingHigh[], int outSwingLow[]) + int TA_FRACTAL_Lookback(int optInLeftBars, int optInRightBars) + TA_RetCode TA_HA(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, double outHAOpen[], double outHAHigh[], double outHALow[], double outHAClose[]) + int TA_HA_Lookback() + TA_RetCode TA_HMA(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_HMA_Lookback(int optInTimePeriod) TA_RetCode TA_HT_DCPERIOD(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_HT_DCPERIOD_Lookback() TA_RetCode TA_HT_DCPHASE(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) @@ -391,6 +434,10 @@ cdef extern from "ta-lib/ta_func.h": int TA_IMI_Lookback(int optInTimePeriod) TA_RetCode TA_KAMA(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_KAMA_Lookback(int optInTimePeriod) + TA_RetCode TA_KC(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int optInATRPeriod, double optInNbDev, int *outBegIdx, int *outNBElement, double outRealUpperBand[], double outRealMiddleBand[], double outRealLowerBand[]) + int TA_KC_Lookback(int optInTimePeriod, int optInATRPeriod, double optInNbDev) + TA_RetCode TA_KDJ(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInFastK_Period, int optInSlowK_Period, TA_MAType optInSlowK_MAType, int optInSlowD_Period, TA_MAType optInSlowD_MAType, int *outBegIdx, int *outNBElement, double outK[], double outD[], double outJ[]) + int TA_KDJ_Lookback(int optInFastK_Period, int optInSlowK_Period, TA_MAType optInSlowK_MAType, int optInSlowD_Period, TA_MAType optInSlowD_MAType) TA_RetCode TA_LINEARREG(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_LINEARREG_Lookback(int optInTimePeriod) TA_RetCode TA_LINEARREG_ANGLE(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) @@ -413,6 +460,10 @@ cdef extern from "ta-lib/ta_func.h": int TA_MACDFIX_Lookback(int optInSignalPeriod) TA_RetCode TA_MAMA(int startIdx, int endIdx, const double inReal[], double optInFastLimit, double optInSlowLimit, int *outBegIdx, int *outNBElement, double outMAMA[], double outFAMA[]) int TA_MAMA_Lookback(double optInFastLimit, double optInSlowLimit) + TA_RetCode TA_MARKETFI(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inVolume[], int *outBegIdx, int *outNBElement, double outReal[]) + int TA_MARKETFI_Lookback() + TA_RetCode TA_MASSI(int startIdx, int endIdx, const double inHigh[], const double inLow[], int optInFastPeriod, int optInSlowPeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_MASSI_Lookback(int optInFastPeriod, int optInSlowPeriod) TA_RetCode TA_MAVP(int startIdx, int endIdx, const double inReal[], const double inPeriods[], int optInMinPeriod, int optInMaxPeriod, TA_MAType optInMAType, int *outBegIdx, int *outNBElement, double outReal[]) int TA_MAVP_Lookback(int optInMinPeriod, int optInMaxPeriod, TA_MAType optInMAType) TA_RetCode TA_MAX(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) @@ -445,14 +496,30 @@ cdef extern from "ta-lib/ta_func.h": int TA_MULT_Lookback() TA_RetCode TA_NATR(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_NATR_Lookback(int optInTimePeriod) + TA_RetCode TA_NVI(int startIdx, int endIdx, const double inClose[], const double inVolume[], int *outBegIdx, int *outNBElement, double outReal[]) + int TA_NVI_Lookback() TA_RetCode TA_OBV(int startIdx, int endIdx, const double inReal[], const double inVolume[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_OBV_Lookback() + TA_RetCode TA_PERCENTILE(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, double optInPercentile, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_PERCENTILE_Lookback(int optInTimePeriod, double optInPercentile) + TA_RetCode TA_PERCENTRANK(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_PERCENTRANK_Lookback(int optInTimePeriod) TA_RetCode TA_PLUS_DI(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_PLUS_DI_Lookback(int optInTimePeriod) TA_RetCode TA_PLUS_DM(int startIdx, int endIdx, const double inHigh[], const double inLow[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_PLUS_DM_Lookback(int optInTimePeriod) TA_RetCode TA_PPO(int startIdx, int endIdx, const double inReal[], int optInFastPeriod, int optInSlowPeriod, TA_MAType optInMAType, int *outBegIdx, int *outNBElement, double outReal[]) int TA_PPO_Lookback(int optInFastPeriod, int optInSlowPeriod, TA_MAType optInMAType) + TA_RetCode TA_PVI(int startIdx, int endIdx, const double inClose[], const double inVolume[], int *outBegIdx, int *outNBElement, double outReal[]) + int TA_PVI_Lookback() + TA_RetCode TA_PVO(int startIdx, int endIdx, const double inVolume[], int optInFastPeriod, int optInSlowPeriod, TA_MAType optInMAType, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_PVO_Lookback(int optInFastPeriod, int optInSlowPeriod, TA_MAType optInMAType) + TA_RetCode TA_PVT(int startIdx, int endIdx, const double inClose[], const double inVolume[], int *outBegIdx, int *outNBElement, double outReal[]) + int TA_PVT_Lookback() + TA_RetCode TA_QSTICK(int startIdx, int endIdx, const double inOpen[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_QSTICK_Lookback(int optInTimePeriod) + TA_RetCode TA_RMA(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_RMA_Lookback(int optInTimePeriod) TA_RetCode TA_ROC(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_ROC_Lookback(int optInTimePeriod) TA_RetCode TA_ROCP(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) @@ -463,6 +530,10 @@ cdef extern from "ta-lib/ta_func.h": int TA_ROCR100_Lookback(int optInTimePeriod) TA_RetCode TA_RSI(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) nogil int TA_RSI_Lookback(int optInTimePeriod) nogil + TA_RetCode TA_RVI(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int optInStdDevPeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_RVI_Lookback(int optInTimePeriod, int optInStdDevPeriod) + TA_RetCode TA_RVOL(int startIdx, int endIdx, const double inVolume[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_RVOL_Lookback(int optInTimePeriod) TA_RetCode TA_SAR(int startIdx, int endIdx, const double inHigh[], const double inLow[], double optInAcceleration, double optInMaximum, int *outBegIdx, int *outNBElement, double outReal[]) int TA_SAR_Lookback(double optInAcceleration, double optInMaximum) TA_RetCode TA_SAREXT(int startIdx, int endIdx, const double inHigh[], const double inLow[], double optInStartValue, double optInOffsetOnReverse, double optInAccelerationInitLong, double optInAccelerationLong, double optInAccelerationMaxLong, double optInAccelerationInitShort, double optInAccelerationShort, double optInAccelerationMaxShort, int *outBegIdx, int *outNBElement, double outReal[]) @@ -473,6 +544,8 @@ cdef extern from "ta-lib/ta_func.h": int TA_SINH_Lookback() TA_RetCode TA_SMA(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_SMA_Lookback(int optInTimePeriod) + TA_RetCode TA_SMI(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int optInFastPeriod, int optInSlowPeriod, int optInSignalPeriod, int *outBegIdx, int *outNBElement, double outSMI[], double outSMISignal[]) + int TA_SMI_Lookback(int optInTimePeriod, int optInFastPeriod, int optInSlowPeriod, int optInSignalPeriod) TA_RetCode TA_SQRT(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_SQRT_Lookback() TA_RetCode TA_STDDEV(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, double optInNbDev, int *outBegIdx, int *outNBElement, double outReal[]) @@ -487,6 +560,8 @@ cdef extern from "ta-lib/ta_func.h": int TA_SUB_Lookback() TA_RetCode TA_SUM(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_SUM_Lookback(int optInTimePeriod) + TA_RetCode TA_SUPERTREND(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, double optInMultiplier, int *outBegIdx, int *outNBElement, double outReal[], int outInteger[]) + int TA_SUPERTREND_Lookback(int optInTimePeriod, double optInMultiplier) TA_RetCode TA_T3(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, double optInVFactor, int *outBegIdx, int *outNBElement, double outReal[]) int TA_T3_Lookback(int optInTimePeriod, double optInVFactor) TA_RetCode TA_TAN(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) @@ -503,18 +578,32 @@ cdef extern from "ta-lib/ta_func.h": int TA_TRIX_Lookback(int optInTimePeriod) TA_RetCode TA_TSF(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_TSF_Lookback(int optInTimePeriod) + TA_RetCode TA_TSI(int startIdx, int endIdx, const double inReal[], int optInFirstPeriod, int optInSecondPeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_TSI_Lookback(int optInFirstPeriod, int optInSecondPeriod) TA_RetCode TA_TYPPRICE(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_TYPPRICE_Lookback() TA_RetCode TA_ULTOSC(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod1, int optInTimePeriod2, int optInTimePeriod3, int *outBegIdx, int *outNBElement, double outReal[]) int TA_ULTOSC_Lookback(int optInTimePeriod1, int optInTimePeriod2, int optInTimePeriod3) TA_RetCode TA_VAR(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, double optInNbDev, int *outBegIdx, int *outNBElement, double outReal[]) int TA_VAR_Lookback(int optInTimePeriod, double optInNbDev) + TA_RetCode TA_VHF(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_VHF_Lookback(int optInTimePeriod) + TA_RetCode TA_VORTEX(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outPlusVI[], double outMinusVI[]) + int TA_VORTEX_Lookback(int optInTimePeriod) + TA_RetCode TA_VWAP(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], const double inVolume[], int *outBegIdx, int *outNBElement, double outReal[]) + int TA_VWAP_Lookback() + TA_RetCode TA_VWMA(int startIdx, int endIdx, const double inReal[], const double inVolume[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_VWMA_Lookback(int optInTimePeriod) + TA_RetCode TA_WAD(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, double outReal[]) + int TA_WAD_Lookback() TA_RetCode TA_WCLPRICE(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_WCLPRICE_Lookback() TA_RetCode TA_WILLR(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_WILLR_Lookback(int optInTimePeriod) TA_RetCode TA_WMA(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_WMA_Lookback(int optInTimePeriod) + TA_RetCode TA_ZLEMA(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) + int TA_ZLEMA_Lookback(int optInTimePeriod) # TALIB functions for TA_SetUnstablePeriod TA_RetCode TA_SetUnstablePeriod(TA_FuncUnstId id, unsigned int unstablePeriod) diff --git a/talib/_ta_lib.pyi b/talib/_ta_lib.pyi index 4356269ff..55b6155bd 100644 --- a/talib/_ta_lib.pyi +++ b/talib/_ta_lib.pyi @@ -13,12 +13,17 @@ class MA_Type(Enum): KAMA = 6 MAMA = 7 T3 = 8 + HMA = 9 + DISABLED = 10 + DEFAULT = 11 + ZLEMA = 12 + RMA = 13 #Overlap Studies Functions def BBANDS( real: NDArray[np.float64], - timeperiod: int= 5, + timeperiod: int= 20, nbdevup: float= 2, nbdevdn: float= 2, matype: MA_Type = MA_Type.SMA @@ -29,11 +34,22 @@ def DEMA( timeperiod: int= 30 )-> NDArray[np.float64]: ... +def DONCHIAN( + high: NDArray[np.float64], + low: NDArray[np.float64], + timeperiod: int= 20 + )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ... + def EMA( real: NDArray[np.float64], timeperiod: int= 30 )-> NDArray[np.float64]: ... +def HMA( + real: NDArray[np.float64], + timeperiod: int= 20 + )-> NDArray[np.float64]: ... + def HT_TRENDLINE(real: NDArray[np.float64])-> NDArray[np.float64]: ... def KAMA( @@ -41,6 +57,15 @@ def KAMA( timeperiod: int= 30 )-> NDArray[np.float64]: ... +def KC( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 20, + atrperiod: int= 10, + nbdev: float= 2.0 + )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ... + def MA( real: NDArray[np.float64], timeperiod: int= 30, @@ -72,6 +97,11 @@ def MIDPRICE( timeperiod: int= 14 )-> NDArray[np.float64]: ... +def RMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + def SAR( high: NDArray[np.float64], low: NDArray[np.float64], @@ -97,6 +127,14 @@ def SMA( timeperiod: int= 30 )-> NDArray[np.float64]: ... +def SUPERTREND( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 10, + multiplier: float= 3.0 + )-> Tuple[NDArray[np.float64], NDArray[np.int32]]: ... + def T3( real: NDArray[np.float64], timeperiod: int= 5, @@ -113,13 +151,32 @@ def TRIMA( timeperiod: int= 30 )-> NDArray[np.float64]: ... +def VWMA( + real: NDArray[np.float64], + volume: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + def WMA( real: NDArray[np.float64], timeperiod: int= 30 )-> NDArray[np.float64]: ... +def ZLEMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + #Momentum Indicator Functions +def AC( + high: NDArray[np.float64], + low: NDArray[np.float64], + fastperiod: int= 5, + slowperiod: int= 34, + signalperiod: int= 5 + )-> NDArray[np.float64]: ... + def ADX( high: NDArray[np.float64], low: NDArray[np.float64], @@ -134,11 +191,18 @@ def ADXR( timeperiod: int= 14 )-> NDArray[np.float64]: ... +def AO( + high: NDArray[np.float64], + low: NDArray[np.float64], + fastperiod: int= 5, + slowperiod: int= 34 + )-> NDArray[np.float64]: ... + def APO( real: NDArray[np.float64], fastperiod: int= 12, slowperiod: int= 26, - matype: MA_Type = MA_Type.SMA + matype: MA_Type = MA_Type.EMA )-> NDArray[np.float64]: ... def AROON( @@ -172,6 +236,23 @@ def CMO( timeperiod: int= 14 )-> NDArray[np.float64]: ... +def CMOU( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def COPPOCK( + real: NDArray[np.float64], + wmaperiod: int= 10, + roc1period: int= 11, + roc2period: int= 14 + )-> NDArray[np.float64]: ... + +def DPO( + real: NDArray[np.float64], + timeperiod: int= 20 + )-> NDArray[np.float64]: ... + def DX( high: NDArray[np.float64], low: NDArray[np.float64], @@ -179,6 +260,41 @@ def DX( timeperiod: int= 14 )-> NDArray[np.float64]: ... +def ER( + real: NDArray[np.float64], + timeperiod: int= 10 + )-> NDArray[np.float64]: ... + +def ERI( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 13 + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def FOSC( + real: NDArray[np.float64], + timeperiod: int= 5 + )-> NDArray[np.float64]: ... + +def FRACTAL( + high: NDArray[np.float64], + low: NDArray[np.float64], + leftbars: int= 2, + rightbars: int= 2 + )-> Tuple[NDArray[np.int32], NDArray[np.int32]]: ... + +def KDJ( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + fastk_period: int= 9, + slowk_period: int= 3, + slowk_matype: MA_Type = MA_Type.RMA, + slowd_period: int= 3, + slowd_matype: MA_Type = MA_Type.RMA + )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ... + def MACD( real: NDArray[np.float64], fastperiod: int= 12, @@ -244,7 +360,13 @@ def PPO( real: NDArray[np.float64], fastperiod: int= 12, slowperiod: int= 26, - matype: MA_Type = MA_Type.SMA + matype: MA_Type = MA_Type.EMA + )-> NDArray[np.float64]: ... + +def QSTICK( + open: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 10 )-> NDArray[np.float64]: ... def ROC( @@ -272,6 +394,16 @@ def RSI( timeperiod: int= 14 )-> NDArray[np.float64]: ... +def SMI( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 13, + fastperiod: int= 2, + slowperiod: int= 25, + signalperiod: int= 9 + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + def STOCH( high: NDArray[np.float64], low: NDArray[np.float64], @@ -305,6 +437,12 @@ def TRIX( timeperiod: int= 30 )-> NDArray[np.float64]: ... +def TSI( + real: NDArray[np.float64], + firstperiod: int= 25, + secondperiod: int= 13 + )-> NDArray[np.float64]: ... + def ULTOSC( high: NDArray[np.float64], low: NDArray[np.float64], @@ -314,6 +452,24 @@ def ULTOSC( timeperiod3: int= 28 )-> NDArray[np.float64]: ... +def VHF( + real: NDArray[np.float64], + timeperiod: int= 28 + )-> NDArray[np.float64]: ... + +def VORTEX( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def WAD( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.float64]: ... + def WILLR( high: NDArray[np.float64], low: NDArray[np.float64], @@ -339,13 +495,73 @@ def ADOSC( slowperiod: int= 10 )-> NDArray[np.float64]: ... +def CMF( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + volume: NDArray[np.float64], + timeperiod: int= 20 + )-> NDArray[np.float64]: ... + +def EFI( + close: NDArray[np.float64], + volume: NDArray[np.float64], + timeperiod: int= 13 + )-> NDArray[np.float64]: ... + +def MARKETFI( + high: NDArray[np.float64], + low: NDArray[np.float64], + volume: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def NVI( + close: NDArray[np.float64], + volume: NDArray[np.float64] + )-> NDArray[np.float64]: ... + def OBV( close: NDArray[np.float64], volume: NDArray[np.float64] )-> NDArray[np.float64]: ... +def PVI( + close: NDArray[np.float64], + volume: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def PVO( + volume: NDArray[np.float64], + fastperiod: int= 12, + slowperiod: int= 26, + matype: int= 1 + )-> NDArray[np.float64]: ... + +def PVT( + close: NDArray[np.float64], + volume: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def RVOL( + volume: NDArray[np.float64], + timeperiod: int= 20 + )-> NDArray[np.float64]: ... + +def VWAP( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + volume: NDArray[np.float64] + )-> NDArray[np.float64]: ... + #Volatility Indicator Functions +def ADR( + high: NDArray[np.float64], + low: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + def ATR( high: NDArray[np.float64], low: NDArray[np.float64], @@ -353,6 +569,20 @@ def ATR( timeperiod: int= 14 )-> NDArray[np.float64]: ... +def CVI( + high: NDArray[np.float64], + low: NDArray[np.float64], + timeperiod: int= 10, + rocperiod: int= 10 + )-> NDArray[np.float64]: ... + +def MASSI( + high: NDArray[np.float64], + low: NDArray[np.float64], + fastperiod: int= 9, + slowperiod: int= 25 + )-> NDArray[np.float64]: ... + def NATR( high: NDArray[np.float64], low: NDArray[np.float64], @@ -360,6 +590,12 @@ def NATR( timeperiod: int= 14 )-> NDArray[np.float64]: ... +def RVI( + real: NDArray[np.float64], + timeperiod: int= 14, + stddevperiod: int= 10 + )-> NDArray[np.float64]: ... + def TRANGE( high: NDArray[np.float64], low: NDArray[np.float64], @@ -375,6 +611,13 @@ def AVGPRICE( close: NDArray[np.float64] )-> NDArray[np.float64]: ... +def HA( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ... + def MEDPRICE( high: NDArray[np.float64], low: NDArray[np.float64] @@ -874,6 +1117,17 @@ def LINEARREG_SLOPE( timeperiod: int= 14 )-> NDArray[np.float64]: ... +def PERCENTILE( + real: NDArray[np.float64], + timeperiod: int= 30, + percentile: float= 50.0 + )-> NDArray[np.float64]: ... + +def PERCENTRANK( + real: NDArray[np.float64], + timeperiod: int= 100 + )-> NDArray[np.float64]: ... + def STDDEV( real: NDArray[np.float64], timeperiod: int= 5, @@ -930,6 +1184,10 @@ def ADD( real1: NDArray[np.float64] )-> NDArray[np.float64]: ... +def CUMSUM( + real: NDArray[np.float64] + )-> NDArray[np.float64]: ... + def DIV( real0: NDArray[np.float64], real1: NDArray[np.float64] @@ -1002,7 +1260,7 @@ def IMI( def stream_BBANDS( real: NDArray[np.float64], - timeperiod: int= 5, + timeperiod: int= 20, nbdevup: float= 2, nbdevdn: float= 2, matype: MA_Type = MA_Type.SMA @@ -1013,11 +1271,22 @@ def stream_DEMA( timeperiod: int= 30 )-> NDArray[np.float64]: ... +def stream_DONCHIAN( + high: NDArray[np.float64], + low: NDArray[np.float64], + timeperiod: int= 20 + )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ... + def stream_EMA( real: NDArray[np.float64], timeperiod: int= 30 )-> NDArray[np.float64]: ... +def stream_HMA( + real: NDArray[np.float64], + timeperiod: int= 20 + )-> NDArray[np.float64]: ... + def stream_HT_TRENDLINE(real: NDArray[np.float64])-> NDArray[np.float64]: ... def stream_KAMA( @@ -1025,6 +1294,15 @@ def stream_KAMA( timeperiod: int= 30 )-> NDArray[np.float64]: ... +def stream_KC( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 20, + atrperiod: int= 10, + nbdev: float= 2.0 + )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ... + def stream_MA( real: NDArray[np.float64], timeperiod: int= 30, @@ -1056,6 +1334,11 @@ def stream_MIDPRICE( timeperiod: int= 14 )-> NDArray[np.float64]: ... +def stream_RMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + def stream_SAR( high: NDArray[np.float64], low: NDArray[np.float64], @@ -1081,6 +1364,14 @@ def stream_SMA( timeperiod: int= 30 )-> NDArray[np.float64]: ... +def stream_SUPERTREND( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 10, + multiplier: float= 3.0 + )-> Tuple[NDArray[np.float64], NDArray[np.int32]]: ... + def stream_T3( real: NDArray[np.float64], timeperiod: int= 5, @@ -1097,13 +1388,32 @@ def stream_TRIMA( timeperiod: int= 30 )-> NDArray[np.float64]: ... +def stream_VWMA( + real: NDArray[np.float64], + volume: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + def stream_WMA( real: NDArray[np.float64], timeperiod: int= 30 )-> NDArray[np.float64]: ... +def stream_ZLEMA( + real: NDArray[np.float64], + timeperiod: int= 30 + )-> NDArray[np.float64]: ... + #Momentum Indicator Functions +def stream_AC( + high: NDArray[np.float64], + low: NDArray[np.float64], + fastperiod: int= 5, + slowperiod: int= 34, + signalperiod: int= 5 + )-> NDArray[np.float64]: ... + def stream_ADX( high: NDArray[np.float64], low: NDArray[np.float64], @@ -1118,11 +1428,18 @@ def stream_ADXR( timeperiod: int= 14 )-> NDArray[np.float64]: ... +def stream_AO( + high: NDArray[np.float64], + low: NDArray[np.float64], + fastperiod: int= 5, + slowperiod: int= 34 + )-> NDArray[np.float64]: ... + def stream_APO( real: NDArray[np.float64], fastperiod: int= 12, slowperiod: int= 26, - matype: MA_Type = MA_Type.SMA + matype: MA_Type = MA_Type.EMA )-> NDArray[np.float64]: ... def stream_AROON( @@ -1156,6 +1473,23 @@ def stream_CMO( timeperiod: int= 14 )-> NDArray[np.float64]: ... +def stream_CMOU( + real: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + +def stream_COPPOCK( + real: NDArray[np.float64], + wmaperiod: int= 10, + roc1period: int= 11, + roc2period: int= 14 + )-> NDArray[np.float64]: ... + +def stream_DPO( + real: NDArray[np.float64], + timeperiod: int= 20 + )-> NDArray[np.float64]: ... + def stream_DX( high: NDArray[np.float64], low: NDArray[np.float64], @@ -1163,6 +1497,41 @@ def stream_DX( timeperiod: int= 14 )-> NDArray[np.float64]: ... +def stream_ER( + real: NDArray[np.float64], + timeperiod: int= 10 + )-> NDArray[np.float64]: ... + +def stream_ERI( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 13 + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def stream_FOSC( + real: NDArray[np.float64], + timeperiod: int= 5 + )-> NDArray[np.float64]: ... + +def stream_FRACTAL( + high: NDArray[np.float64], + low: NDArray[np.float64], + leftbars: int= 2, + rightbars: int= 2 + )-> Tuple[NDArray[np.int32], NDArray[np.int32]]: ... + +def stream_KDJ( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + fastk_period: int= 9, + slowk_period: int= 3, + slowk_matype: MA_Type = MA_Type.RMA, + slowd_period: int= 3, + slowd_matype: MA_Type = MA_Type.RMA + )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ... + def stream_MACD( real: NDArray[np.float64], fastperiod: int= 12, @@ -1228,7 +1597,13 @@ def stream_PPO( real: NDArray[np.float64], fastperiod: int= 12, slowperiod: int= 26, - matype: MA_Type = MA_Type.SMA + matype: MA_Type = MA_Type.EMA + )-> NDArray[np.float64]: ... + +def stream_QSTICK( + open: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 10 )-> NDArray[np.float64]: ... def stream_ROC( @@ -1256,6 +1631,16 @@ def stream_RSI( timeperiod: int= 14 )-> NDArray[np.float64]: ... +def stream_SMI( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 13, + fastperiod: int= 2, + slowperiod: int= 25, + signalperiod: int= 9 + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + def stream_STOCH( high: NDArray[np.float64], low: NDArray[np.float64], @@ -1289,6 +1674,12 @@ def stream_TRIX( timeperiod: int= 30 )-> NDArray[np.float64]: ... +def stream_TSI( + real: NDArray[np.float64], + firstperiod: int= 25, + secondperiod: int= 13 + )-> NDArray[np.float64]: ... + def stream_ULTOSC( high: NDArray[np.float64], low: NDArray[np.float64], @@ -1298,6 +1689,24 @@ def stream_ULTOSC( timeperiod3: int= 28 )-> NDArray[np.float64]: ... +def stream_VHF( + real: NDArray[np.float64], + timeperiod: int= 28 + )-> NDArray[np.float64]: ... + +def stream_VORTEX( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + timeperiod: int= 14 + )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ... + +def stream_WAD( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> NDArray[np.float64]: ... + def stream_WILLR( high: NDArray[np.float64], low: NDArray[np.float64], @@ -1323,13 +1732,73 @@ def stream_ADOSC( slowperiod: int= 10 )-> NDArray[np.float64]: ... +def stream_CMF( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + volume: NDArray[np.float64], + timeperiod: int= 20 + )-> NDArray[np.float64]: ... + +def stream_EFI( + close: NDArray[np.float64], + volume: NDArray[np.float64], + timeperiod: int= 13 + )-> NDArray[np.float64]: ... + +def stream_MARKETFI( + high: NDArray[np.float64], + low: NDArray[np.float64], + volume: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def stream_NVI( + close: NDArray[np.float64], + volume: NDArray[np.float64] + )-> NDArray[np.float64]: ... + def stream_OBV( close: NDArray[np.float64], volume: NDArray[np.float64] )-> NDArray[np.float64]: ... +def stream_PVI( + close: NDArray[np.float64], + volume: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def stream_PVO( + volume: NDArray[np.float64], + fastperiod: int= 12, + slowperiod: int= 26, + matype: int= 1 + )-> NDArray[np.float64]: ... + +def stream_PVT( + close: NDArray[np.float64], + volume: NDArray[np.float64] + )-> NDArray[np.float64]: ... + +def stream_RVOL( + volume: NDArray[np.float64], + timeperiod: int= 20 + )-> NDArray[np.float64]: ... + +def stream_VWAP( + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64], + volume: NDArray[np.float64] + )-> NDArray[np.float64]: ... + #Volatility Indicator Functions +def stream_ADR( + high: NDArray[np.float64], + low: NDArray[np.float64], + timeperiod: int= 14 + )-> NDArray[np.float64]: ... + def stream_ATR( high: NDArray[np.float64], low: NDArray[np.float64], @@ -1337,6 +1806,20 @@ def stream_ATR( timeperiod: int= 14 )-> NDArray[np.float64]: ... +def stream_CVI( + high: NDArray[np.float64], + low: NDArray[np.float64], + timeperiod: int= 10, + rocperiod: int= 10 + )-> NDArray[np.float64]: ... + +def stream_MASSI( + high: NDArray[np.float64], + low: NDArray[np.float64], + fastperiod: int= 9, + slowperiod: int= 25 + )-> NDArray[np.float64]: ... + def stream_NATR( high: NDArray[np.float64], low: NDArray[np.float64], @@ -1344,6 +1827,12 @@ def stream_NATR( timeperiod: int= 14 )-> NDArray[np.float64]: ... +def stream_RVI( + real: NDArray[np.float64], + timeperiod: int= 14, + stddevperiod: int= 10 + )-> NDArray[np.float64]: ... + def stream_TRANGE( high: NDArray[np.float64], low: NDArray[np.float64], @@ -1359,6 +1848,13 @@ def stream_AVGPRICE( close: NDArray[np.float64] )-> NDArray[np.float64]: ... +def stream_HA( + open: NDArray[np.float64], + high: NDArray[np.float64], + low: NDArray[np.float64], + close: NDArray[np.float64] + )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ... + def stream_MEDPRICE( high: NDArray[np.float64], low: NDArray[np.float64] @@ -1858,6 +2354,17 @@ def stream_LINEARREG_SLOPE( timeperiod: int= 14 )-> NDArray[np.float64]: ... +def stream_PERCENTILE( + real: NDArray[np.float64], + timeperiod: int= 30, + percentile: float= 50.0 + )-> NDArray[np.float64]: ... + +def stream_PERCENTRANK( + real: NDArray[np.float64], + timeperiod: int= 100 + )-> NDArray[np.float64]: ... + def stream_STDDEV( real: NDArray[np.float64], timeperiod: int= 5, @@ -1914,6 +2421,10 @@ def stream_ADD( real1: NDArray[np.float64] )-> NDArray[np.float64]: ... +def stream_CUMSUM( + real: NDArray[np.float64] + )-> NDArray[np.float64]: ... + def stream_DIV( real0: NDArray[np.float64], real1: NDArray[np.float64] diff --git a/talib/abstract.pyi b/talib/abstract.pyi index ef6c7da26..d4147f2c4 100644 --- a/talib/abstract.pyi +++ b/talib/abstract.pyi @@ -64,7 +64,7 @@ Hilbert Transform - Trend vs Cycle Mode (Cycle Indicators) Inputs: real: (any ndarray) Outputs: - integer (values are -100, 0 or 100)""" + integer""" @overload def HT_TRENDMODE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload @@ -84,6 +84,19 @@ def ADD(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def ADD(real: pd.DataFrame) -> pd.Series: ... +"""CUMSUM(real) + +Cumulative Sum (Math Operators) + +Inputs: + real: (any ndarray) +Outputs: + real""" +@overload +def CUMSUM(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def CUMSUM(real: pd.DataFrame) -> pd.Series: ... + """DIV(real0, real1) Vector Arithmetic Div (Math Operators) @@ -122,7 +135,7 @@ Inputs: Parameters: timeperiod: 30 Outputs: - integer (values are -100, 0 or 100)""" + integer""" @overload def MAXINDEX(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload @@ -152,7 +165,7 @@ Inputs: Parameters: timeperiod: 30 Outputs: - integer (values are -100, 0 or 100)""" + integer""" @overload def MININDEX(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload @@ -428,6 +441,23 @@ def TANH(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def TANH(real: pd.DataFrame) -> pd.Series: ... +"""AC(high, low[, fastperiod=?, slowperiod=?, signalperiod=?]) + +Accelerator/Decelerator Oscillator (Momentum Indicators) + +Inputs: + prices: ['high', 'low'] +Parameters: + fastperiod: 5 + slowperiod: 34 + signalperiod: 5 +Outputs: + real""" +@overload +def AC(real: Union[pd.Series, np.ndarray], fastperiod=5, slowperiod=34, signalperiod=5) -> np.ndarray: ... +@overload +def AC(real: pd.DataFrame, fastperiod=5, slowperiod=34, signalperiod=5) -> pd.Series: ... + """ADX(high, low, close[, timeperiod=?]) Average Directional Movement Index (Momentum Indicators) @@ -458,6 +488,22 @@ def ADXR(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def ADXR(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... +"""AO(high, low[, fastperiod=?, slowperiod=?]) + +Awesome Oscillator (Momentum Indicators) + +Inputs: + prices: ['high', 'low'] +Parameters: + fastperiod: 5 + slowperiod: 34 +Outputs: + real""" +@overload +def AO(real: Union[pd.Series, np.ndarray], fastperiod=5, slowperiod=34) -> np.ndarray: ... +@overload +def AO(real: pd.DataFrame, fastperiod=5, slowperiod=34) -> pd.Series: ... + """APO(real[, fastperiod=?, slowperiod=?, matype=?]) Absolute Price Oscillator (Momentum Indicators) @@ -467,13 +513,13 @@ Inputs: Parameters: fastperiod: 12 slowperiod: 26 - matype: 0 (Simple Moving Average) + matype: 1 (Exponential Moving Average) Outputs: real""" @overload -def APO(real: Union[pd.Series, np.ndarray], fastperiod=12, slowperiod=26, matype=0) -> np.ndarray: ... +def APO(real: Union[pd.Series, np.ndarray], fastperiod=12, slowperiod=26, matype=1) -> np.ndarray: ... @overload -def APO(real: pd.DataFrame, fastperiod=12, slowperiod=26, matype=0) -> pd.Series: ... +def APO(real: pd.DataFrame, fastperiod=12, slowperiod=26, matype=1) -> pd.Series: ... """AROON(high, low[, timeperiod=?]) @@ -549,6 +595,53 @@ def CMO(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def CMO(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... +"""CMOU(real[, timeperiod=?]) + +Chande Momentum Oscillator (Unsmoothed) (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def CMOU(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def CMOU(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""COPPOCK(real[, wmaperiod=?, roc1period=?, roc2period=?]) + +Coppock Curve (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + wmaperiod: 10 + roc1period: 11 + roc2period: 14 +Outputs: + real""" +@overload +def COPPOCK(real: Union[pd.Series, np.ndarray], wmaperiod=10, roc1period=11, roc2period=14) -> np.ndarray: ... +@overload +def COPPOCK(real: pd.DataFrame, wmaperiod=10, roc1period=11, roc2period=14) -> pd.Series: ... + +"""DPO(real[, timeperiod=?]) + +Detrended Price Oscillator (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 20 +Outputs: + real""" +@overload +def DPO(real: Union[pd.Series, np.ndarray], timeperiod=20) -> np.ndarray: ... +@overload +def DPO(real: pd.DataFrame, timeperiod=20) -> pd.Series: ... + """DX(high, low, close[, timeperiod=?]) Directional Movement Index (Momentum Indicators) @@ -564,6 +657,105 @@ def DX(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def DX(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... +"""ER(real[, timeperiod=?]) + +Kaufman Efficiency Ratio (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 10 +Outputs: + real""" +@overload +def ER(real: Union[pd.Series, np.ndarray], timeperiod=10) -> np.ndarray: ... +@overload +def ER(real: pd.DataFrame, timeperiod=10) -> pd.Series: ... + +"""ERI(high, low, close[, timeperiod=?]) + +Elder Ray Index (Bull Power / Bear Power) (Momentum Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + timeperiod: 13 +Outputs: + bullpower + bearpower""" +@overload +def ERI(real: Union[pd.Series, np.ndarray], timeperiod=13) -> Tuple[np.ndarray, np.ndarray]: ... +@overload +def ERI(real: pd.DataFrame, timeperiod=13) -> pd.DataFrame: ... + +"""FOSC(real[, timeperiod=?]) + +Forecast Oscillator (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 5 +Outputs: + real""" +@overload +def FOSC(real: Union[pd.Series, np.ndarray], timeperiod=5) -> np.ndarray: ... +@overload +def FOSC(real: pd.DataFrame, timeperiod=5) -> pd.Series: ... + +"""FRACTAL(high, low[, leftbars=?, rightbars=?]) + +Williams Fractal (Momentum Indicators) + +Inputs: + prices: ['high', 'low'] +Parameters: + leftbars: 2 + rightbars: 2 +Outputs: + swinghigh + swinglow""" +@overload +def FRACTAL(real: Union[pd.Series, np.ndarray], leftbars=2, rightbars=2) -> Tuple[np.ndarray, np.ndarray]: ... +@overload +def FRACTAL(real: pd.DataFrame, leftbars=2, rightbars=2) -> pd.DataFrame: ... + +"""IMI(open, close[, timeperiod=?]) + +Intraday Momentum Index (Momentum Indicators) + +Inputs: + prices: ['open', 'close'] +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def IMI(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def IMI(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + +"""KDJ(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?]) + +KDJ Stochastic (Momentum Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + fastk_period: 9 + slowk_period: 3 + slowk_matype: 13 (Wilder's Smoothed Moving Average) + slowd_period: 3 + slowd_matype: 13 (Wilder's Smoothed Moving Average) +Outputs: + k + d + j""" +@overload +def KDJ(real: Union[pd.Series, np.ndarray], fastk_period=9, slowk_period=3, slowk_matype=13, slowd_period=3, slowd_matype=13) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: ... +@overload +def KDJ(real: pd.DataFrame, fastk_period=9, slowk_period=3, slowk_matype=13, slowd_period=3, slowd_matype=13) -> pd.DataFrame: ... + """MACD(real[, fastperiod=?, slowperiod=?, signalperiod=?]) Moving Average Convergence/Divergence (Momentum Indicators) @@ -591,11 +783,11 @@ Inputs: real: (any ndarray) Parameters: fastperiod: 12 - fastmatype: 0 + fastmatype: 0 (Simple Moving Average) slowperiod: 26 - slowmatype: 0 + slowmatype: 0 (Simple Moving Average) signalperiod: 9 - signalmatype: 0 + signalmatype: 0 (Simple Moving Average) Outputs: macd macdsignal @@ -721,13 +913,28 @@ Inputs: Parameters: fastperiod: 12 slowperiod: 26 - matype: 0 (Simple Moving Average) + matype: 1 (Exponential Moving Average) +Outputs: + real""" +@overload +def PPO(real: Union[pd.Series, np.ndarray], fastperiod=12, slowperiod=26, matype=1) -> np.ndarray: ... +@overload +def PPO(real: pd.DataFrame, fastperiod=12, slowperiod=26, matype=1) -> pd.Series: ... + +"""QSTICK(open, close[, timeperiod=?]) + +Qstick (Momentum Indicators) + +Inputs: + prices: ['open', 'close'] +Parameters: + timeperiod: 10 Outputs: real""" @overload -def PPO(real: Union[pd.Series, np.ndarray], fastperiod=12, slowperiod=26, matype=0) -> np.ndarray: ... +def QSTICK(real: Union[pd.Series, np.ndarray], timeperiod=10) -> np.ndarray: ... @overload -def PPO(real: pd.DataFrame, fastperiod=12, slowperiod=26, matype=0) -> pd.Series: ... +def QSTICK(real: pd.DataFrame, timeperiod=10) -> pd.Series: ... """ROC(real[, timeperiod=?]) @@ -804,6 +1011,25 @@ def RSI(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def RSI(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... +"""SMI(high, low, close[, timeperiod=?, fastperiod=?, slowperiod=?, signalperiod=?]) + +Stochastic Momentum Index (Momentum Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + timeperiod: 13 + fastperiod: 2 + slowperiod: 25 + signalperiod: 9 +Outputs: + smi + smisignal""" +@overload +def SMI(real: Union[pd.Series, np.ndarray], timeperiod=13, fastperiod=2, slowperiod=25, signalperiod=9) -> Tuple[np.ndarray, np.ndarray]: ... +@overload +def SMI(real: pd.DataFrame, timeperiod=13, fastperiod=2, slowperiod=25, signalperiod=9) -> pd.DataFrame: ... + """STOCH(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?]) Stochastic (Momentum Indicators) @@ -813,9 +1039,9 @@ Inputs: Parameters: fastk_period: 5 slowk_period: 3 - slowk_matype: 0 + slowk_matype: 0 (Simple Moving Average) slowd_period: 3 - slowd_matype: 0 + slowd_matype: 0 (Simple Moving Average) Outputs: slowk slowd""" @@ -833,7 +1059,7 @@ Inputs: Parameters: fastk_period: 5 fastd_period: 3 - fastd_matype: 0 + fastd_matype: 0 (Simple Moving Average) Outputs: fastk fastd""" @@ -852,7 +1078,7 @@ Parameters: timeperiod: 14 fastk_period: 5 fastd_period: 3 - fastd_matype: 0 + fastd_matype: 0 (Simple Moving Average) Outputs: fastk fastd""" @@ -876,6 +1102,22 @@ def TRIX(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def TRIX(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... +"""TSI(real[, firstperiod=?, secondperiod=?]) + +True Strength Index (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + firstperiod: 25 + secondperiod: 13 +Outputs: + real""" +@overload +def TSI(real: Union[pd.Series, np.ndarray], firstperiod=25, secondperiod=13) -> np.ndarray: ... +@overload +def TSI(real: pd.DataFrame, firstperiod=25, secondperiod=13) -> pd.Series: ... + """ULTOSC(high, low, close[, timeperiod1=?, timeperiod2=?, timeperiod3=?]) Ultimate Oscillator (Momentum Indicators) @@ -893,6 +1135,50 @@ def ULTOSC(real: Union[pd.Series, np.ndarray], timeperiod1=7, timeperiod2=14, ti @overload def ULTOSC(real: pd.DataFrame, timeperiod1=7, timeperiod2=14, timeperiod3=28) -> pd.Series: ... +"""VHF(real[, timeperiod=?]) + +Vertical Horizontal Filter (Momentum Indicators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 28 +Outputs: + real""" +@overload +def VHF(real: Union[pd.Series, np.ndarray], timeperiod=28) -> np.ndarray: ... +@overload +def VHF(real: pd.DataFrame, timeperiod=28) -> pd.Series: ... + +"""VORTEX(high, low, close[, timeperiod=?]) + +Vortex Indicator (Momentum Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + timeperiod: 14 +Outputs: + plusvi + minusvi""" +@overload +def VORTEX(real: Union[pd.Series, np.ndarray], timeperiod=14) -> Tuple[np.ndarray, np.ndarray]: ... +@overload +def VORTEX(real: pd.DataFrame, timeperiod=14) -> pd.DataFrame: ... + +"""WAD(high, low, close) + +Williams' Accumulation/Distribution (Momentum Indicators) + +Inputs: + prices: ['high', 'low', 'close'] +Outputs: + real""" +@overload +def WAD(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def WAD(real: pd.DataFrame) -> pd.Series: ... + """WILLR(high, low, close[, timeperiod=?]) Williams' %R (Momentum Indicators) @@ -908,6 +1194,23 @@ def WILLR(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def WILLR(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... +"""ACCBANDS(high, low, close[, timeperiod=?]) + +Acceleration Bands (Overlap Studies) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + timeperiod: 20 +Outputs: + upperband + middleband + lowerband""" +@overload +def ACCBANDS(real: Union[pd.Series, np.ndarray], timeperiod=20) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: ... +@overload +def ACCBANDS(real: pd.DataFrame, timeperiod=20) -> pd.DataFrame: ... + """BBANDS(real[, timeperiod=?, nbdevup=?, nbdevdn=?, matype=?]) Bollinger Bands (Overlap Studies) @@ -915,7 +1218,7 @@ Bollinger Bands (Overlap Studies) Inputs: real: (any ndarray) Parameters: - timeperiod: 5 + timeperiod: 20 nbdevup: 2.0 nbdevdn: 2.0 matype: 0 (Simple Moving Average) @@ -924,9 +1227,9 @@ Outputs: middleband lowerband""" @overload -def BBANDS(real: Union[pd.Series, np.ndarray], timeperiod=5, nbdevup=2.0, nbdevdn=2.0, matype=0) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: ... +def BBANDS(real: Union[pd.Series, np.ndarray], timeperiod=20, nbdevup=2.0, nbdevdn=2.0, matype=0) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: ... @overload -def BBANDS(real: pd.DataFrame, timeperiod=5, nbdevup=2.0, nbdevdn=2.0, matype=0) -> pd.DataFrame: ... +def BBANDS(real: pd.DataFrame, timeperiod=20, nbdevup=2.0, nbdevdn=2.0, matype=0) -> pd.DataFrame: ... """DEMA(real[, timeperiod=?]) @@ -943,6 +1246,23 @@ def DEMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def DEMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... +"""DONCHIAN(high, low[, timeperiod=?]) + +Donchian Channels (Overlap Studies) + +Inputs: + prices: ['high', 'low'] +Parameters: + timeperiod: 20 +Outputs: + upperband + middleband + lowerband""" +@overload +def DONCHIAN(real: Union[pd.Series, np.ndarray], timeperiod=20) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: ... +@overload +def DONCHIAN(real: pd.DataFrame, timeperiod=20) -> pd.DataFrame: ... + """EMA(real[, timeperiod=?]) Exponential Moving Average (Overlap Studies) @@ -958,6 +1278,21 @@ def EMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def EMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... +"""HMA(real[, timeperiod=?]) + +Hull Moving Average (Overlap Studies) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 20 +Outputs: + real""" +@overload +def HMA(real: Union[pd.Series, np.ndarray], timeperiod=20) -> np.ndarray: ... +@overload +def HMA(real: pd.DataFrame, timeperiod=20) -> pd.Series: ... + """HT_TRENDLINE(real) Hilbert Transform - Instantaneous Trendline (Overlap Studies) @@ -986,6 +1321,25 @@ def KAMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def KAMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... +"""KC(high, low, close[, timeperiod=?, atrperiod=?, nbdev=?]) + +Keltner Channels (Overlap Studies) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + timeperiod: 20 + atrperiod: 10 + nbdev: 2.0 +Outputs: + upperband + middleband + lowerband""" +@overload +def KC(real: Union[pd.Series, np.ndarray], timeperiod=20, atrperiod=10, nbdev=2.0) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: ... +@overload +def KC(real: pd.DataFrame, timeperiod=20, atrperiod=10, nbdev=2.0) -> pd.DataFrame: ... + """MA(real[, timeperiod=?, matype=?]) Moving average (Overlap Studies) @@ -1067,6 +1421,21 @@ def MIDPRICE(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: . @overload def MIDPRICE(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... +"""RMA(real[, timeperiod=?]) + +Wilder's Smoothed Moving Average (Overlap Studies) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + real""" +@overload +def RMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... +@overload +def RMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... + """SAR(high, low[, acceleration=?, maximum=?]) Parabolic SAR (Overlap Studies) @@ -1120,6 +1489,23 @@ def SMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def SMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... +"""SUPERTREND(high, low, close[, timeperiod=?, multiplier=?]) + +SuperTrend (Overlap Studies) + +Inputs: + prices: ['high', 'low', 'close'] +Parameters: + timeperiod: 10 + multiplier: 3.0 +Outputs: + real + integer""" +@overload +def SUPERTREND(real: Union[pd.Series, np.ndarray], timeperiod=10, multiplier=3.0) -> Tuple[np.ndarray, np.ndarray]: ... +@overload +def SUPERTREND(real: pd.DataFrame, timeperiod=10, multiplier=3.0) -> pd.DataFrame: ... + """T3(real[, timeperiod=?, vfactor=?]) Triple Exponential Moving Average (T3) (Overlap Studies) @@ -1166,6 +1552,22 @@ def TRIMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def TRIMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... +"""VWMA(real, volume[, timeperiod=?]) + +Volume Weighted Moving Average (Overlap Studies) + +Inputs: + real: (any ndarray) + prices: ['volume'] +Parameters: + timeperiod: 30 +Outputs: + real""" +@overload +def VWMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... +@overload +def VWMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... + """WMA(real[, timeperiod=?]) Weighted Moving Average (Overlap Studies) @@ -1181,6 +1583,21 @@ def WMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def WMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... +"""ZLEMA(real[, timeperiod=?]) + +Zero-Lag Exponential Moving Average (Overlap Studies) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 +Outputs: + real""" +@overload +def ZLEMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... +@overload +def ZLEMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... + """CDL2CROWS(open, high, low, close) Two Crows (Pattern Recognition) @@ -1222,7 +1639,7 @@ def CDL3INSIDE(real: pd.DataFrame) -> pd.Series: ... """CDL3LINESTRIKE(open, high, low, close) -Three-Line Strike (Pattern Recognition) +Three-Line Strike (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] @@ -1988,6 +2405,21 @@ def CDLXSIDEGAP3METHODS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLXSIDEGAP3METHODS(real: pd.DataFrame) -> pd.Series: ... +"""AVGDEV(real[, timeperiod=?]) + +Average Deviation (Price Transform) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def AVGDEV(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def AVGDEV(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + """AVGPRICE(open, high, low, close) Average Price (Price Transform) @@ -2001,6 +2433,22 @@ def AVGPRICE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def AVGPRICE(real: pd.DataFrame) -> pd.Series: ... +"""HA(open, high, low, close) + +Heikin-Ashi Candles (Price Transform) + +Inputs: + prices: ['open', 'high', 'low', 'close'] +Outputs: + haopen + hahigh + halow + haclose""" +@overload +def HA(real: Union[pd.Series, np.ndarray]) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: ... +@overload +def HA(real: pd.DataFrame) -> pd.DataFrame: ... + """MEDPRICE(high, low) Median Price (Price Transform) @@ -2132,6 +2580,37 @@ def LINEARREG_SLOPE(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.nda @overload def LINEARREG_SLOPE(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... +"""PERCENTILE(real[, timeperiod=?, percentile=?]) + +Percentile (nearest rank) (Statistic Functions) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 30 + percentile: 50.0 +Outputs: + real""" +@overload +def PERCENTILE(real: Union[pd.Series, np.ndarray], timeperiod=30, percentile=50.0) -> np.ndarray: ... +@overload +def PERCENTILE(real: pd.DataFrame, timeperiod=30, percentile=50.0) -> pd.Series: ... + +"""PERCENTRANK(real[, timeperiod=?]) + +Percent Rank (Statistic Functions) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 100 +Outputs: + real""" +@overload +def PERCENTRANK(real: Union[pd.Series, np.ndarray], timeperiod=100) -> np.ndarray: ... +@overload +def PERCENTRANK(real: pd.DataFrame, timeperiod=100) -> pd.Series: ... + """STDDEV(real[, timeperiod=?, nbdev=?]) Standard Deviation (Statistic Functions) @@ -2179,6 +2658,21 @@ def VAR(real: Union[pd.Series, np.ndarray], timeperiod=5, nbdev=1.0) -> np.ndarr @overload def VAR(real: pd.DataFrame, timeperiod=5, nbdev=1.0) -> pd.Series: ... +"""ADR(high, low[, timeperiod=?]) + +Average Day Range (Volatility Indicators) + +Inputs: + prices: ['high', 'low'] +Parameters: + timeperiod: 14 +Outputs: + real""" +@overload +def ADR(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... +@overload +def ADR(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... + """ATR(high, low, close[, timeperiod=?]) Average True Range (Volatility Indicators) @@ -2194,6 +2688,38 @@ def ATR(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def ATR(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... +"""CVI(high, low[, timeperiod=?, rocperiod=?]) + +Chaikin's Volatility (Volatility Indicators) + +Inputs: + prices: ['high', 'low'] +Parameters: + timeperiod: 10 + rocperiod: 10 +Outputs: + real""" +@overload +def CVI(real: Union[pd.Series, np.ndarray], timeperiod=10, rocperiod=10) -> np.ndarray: ... +@overload +def CVI(real: pd.DataFrame, timeperiod=10, rocperiod=10) -> pd.Series: ... + +"""MASSI(high, low[, fastperiod=?, slowperiod=?]) + +Mass Index (Volatility Indicators) + +Inputs: + prices: ['high', 'low'] +Parameters: + fastperiod: 9 + slowperiod: 25 +Outputs: + real""" +@overload +def MASSI(real: Union[pd.Series, np.ndarray], fastperiod=9, slowperiod=25) -> np.ndarray: ... +@overload +def MASSI(real: pd.DataFrame, fastperiod=9, slowperiod=25) -> pd.Series: ... + """NATR(high, low, close[, timeperiod=?]) Normalized Average True Range (Volatility Indicators) @@ -2209,6 +2735,22 @@ def NATR(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def NATR(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... +"""RVI(real[, timeperiod=?, stddevperiod=?]) + +Relative Volatility Index (Volatility Indicators) + +Inputs: + real: (any ndarray) +Parameters: + timeperiod: 14 + stddevperiod: 10 +Outputs: + real""" +@overload +def RVI(real: Union[pd.Series, np.ndarray], timeperiod=14, stddevperiod=10) -> np.ndarray: ... +@overload +def RVI(real: pd.DataFrame, timeperiod=14, stddevperiod=10) -> pd.Series: ... + """TRANGE(high, low, close) True Range (Volatility Indicators) @@ -2251,6 +2793,62 @@ def ADOSC(real: Union[pd.Series, np.ndarray], fastperiod=3, slowperiod=10) -> np @overload def ADOSC(real: pd.DataFrame, fastperiod=3, slowperiod=10) -> pd.Series: ... +"""CMF(high, low, close, volume[, timeperiod=?]) + +Chaikin Money Flow (Volume Indicators) + +Inputs: + prices: ['high', 'low', 'close', 'volume'] +Parameters: + timeperiod: 20 +Outputs: + real""" +@overload +def CMF(real: Union[pd.Series, np.ndarray], timeperiod=20) -> np.ndarray: ... +@overload +def CMF(real: pd.DataFrame, timeperiod=20) -> pd.Series: ... + +"""EFI(close, volume[, timeperiod=?]) + +Elder's Force Index (Volume Indicators) + +Inputs: + prices: ['close', 'volume'] +Parameters: + timeperiod: 13 +Outputs: + real""" +@overload +def EFI(real: Union[pd.Series, np.ndarray], timeperiod=13) -> np.ndarray: ... +@overload +def EFI(real: pd.DataFrame, timeperiod=13) -> pd.Series: ... + +"""MARKETFI(high, low, volume) + +Market Facilitation Index (Volume Indicators) + +Inputs: + prices: ['high', 'low', 'volume'] +Outputs: + real""" +@overload +def MARKETFI(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def MARKETFI(real: pd.DataFrame) -> pd.Series: ... + +"""NVI(close, volume) + +Negative Volume Index (Volume Indicators) + +Inputs: + prices: ['close', 'volume'] +Outputs: + real""" +@overload +def NVI(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def NVI(real: pd.DataFrame) -> pd.Series: ... + """OBV(real, volume) On Balance Volume (Volume Indicators) @@ -2265,3 +2863,74 @@ def OBV(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def OBV(real: pd.DataFrame) -> pd.Series: ... +"""PVI(close, volume) + +Positive Volume Index (Volume Indicators) + +Inputs: + prices: ['close', 'volume'] +Outputs: + real""" +@overload +def PVI(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def PVI(real: pd.DataFrame) -> pd.Series: ... + +"""PVO(volume[, fastperiod=?, slowperiod=?, matype=?]) + +Percentage Volume Oscillator (Volume Indicators) + +Inputs: + prices: ['volume'] +Parameters: + fastperiod: 12 + slowperiod: 26 + matype: 1 (Exponential Moving Average) +Outputs: + real""" +@overload +def PVO(real: Union[pd.Series, np.ndarray], fastperiod=12, slowperiod=26, matype=1) -> np.ndarray: ... +@overload +def PVO(real: pd.DataFrame, fastperiod=12, slowperiod=26, matype=1) -> pd.Series: ... + +"""PVT(close, volume) + +Price Volume Trend (Volume Indicators) + +Inputs: + prices: ['close', 'volume'] +Outputs: + real""" +@overload +def PVT(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def PVT(real: pd.DataFrame) -> pd.Series: ... + +"""RVOL(volume[, timeperiod=?]) + +Relative Volume (Volume Indicators) + +Inputs: + prices: ['volume'] +Parameters: + timeperiod: 20 +Outputs: + real""" +@overload +def RVOL(real: Union[pd.Series, np.ndarray], timeperiod=20) -> np.ndarray: ... +@overload +def RVOL(real: pd.DataFrame, timeperiod=20) -> pd.Series: ... + +"""VWAP(high, low, close, volume) + +Volume Weighted Average Price (Volume Indicators) + +Inputs: + prices: ['high', 'low', 'close', 'volume'] +Outputs: + real""" +@overload +def VWAP(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... +@overload +def VWAP(real: pd.DataFrame) -> pd.Series: ... + diff --git a/talib/deprecated.py b/talib/deprecated.py index 264fc46ce..6d1fe1715 100644 --- a/talib/deprecated.py +++ b/talib/deprecated.py @@ -1,2 +1,3 @@ # TA_MAType enums -MA_SMA, MA_EMA, MA_WMA, MA_DEMA, MA_TEMA, MA_TRIMA, MA_KAMA, MA_MAMA, MA_T3 = range(9) +MA_SMA, MA_EMA, MA_WMA, MA_DEMA, MA_TEMA, MA_TRIMA, MA_KAMA, MA_MAMA, MA_T3, \ + MA_HMA, MA_DISABLED, MA_DEFAULT, MA_ZLEMA, MA_RMA = range(14) diff --git a/tests/test_abstract.py b/tests/test_abstract.py index c7440e58c..f78ed1bdf 100644 --- a/tests/test_abstract.py +++ b/tests/test_abstract.py @@ -134,7 +134,7 @@ def test_info(): stochrsi.parameters = {'fastd_matype': talib.MA_Type.EMA} expected = { 'display_name': 'Stochastic Relative Strength Index', - 'function_flags': ['Function has an unstable period'], + 'function_flags': ['Function has a streaming API'], 'group': 'Momentum Indicators', 'input_names': OrderedDict([('price', 'open')]), 'name': 'STOCHRSI', @@ -154,7 +154,8 @@ def test_info(): expected = { 'display_name': 'Bollinger Bands', - 'function_flags': ['Output scale same as input'], + 'function_flags': ['Output scale same as input', + 'Function has a streaming API'], 'group': 'Overlap Studies', 'input_names': OrderedDict([('price', 'close')]), 'name': 'BBANDS', @@ -165,7 +166,7 @@ def test_info(): ]), 'output_names': ['upperband', 'middleband', 'lowerband'], 'parameters': OrderedDict([ - ('timeperiod', 5), + ('timeperiod', 20), ('nbdevup', 2), ('nbdevdn', 2), ('matype', 0), diff --git a/tests/test_func.py b/tests/test_func.py index cde20baa7..9f05ba7c7 100644 --- a/tests/test_func.py +++ b/tests/test_func.py @@ -3,15 +3,22 @@ import pytest import talib -from talib import func +from talib import abstract, func def test_talib_version(): - assert talib.__ta_version__[:5] == b'0.7.1' + assert talib.__ta_version__[:5] == b'0.8.1' def test_num_functions(): - assert len(talib.get_functions()) == 161 + assert len(talib.get_functions()) == 201 + assert len(talib.__TA_FUNCTION_NAMES__) == 201 + + +def test_every_grouped_function_is_bound(): + # get_functions() reads the hand-written group dict; __TA_FUNCTION_NAMES__ + # comes from the C header. A count on one side cannot see a hole in the other. + assert set(talib.get_functions()) == set(talib.__TA_FUNCTION_NAMES__) def test_input_wrong_type(): @@ -71,6 +78,7 @@ def _unstable_period_cases(): close = np.cumsum(rs.randn(n)) + 100.0 high = close + rs.rand(n) + 0.5 low = close - rs.rand(n) - 0.5 + open_ = close + rs.rand(n) - 0.5 return { 'ADX': lambda: func.ADX(high, low, close), 'ATR': lambda: func.ATR(high, low, close), @@ -92,6 +100,9 @@ def _unstable_period_cases(): 'PLUS_DM': lambda: func.PLUS_DM(high, low), 'RSI': lambda: func.RSI(close), 'T3': lambda: func.T3(close), + 'RMA': lambda: func.RMA(close), + 'HA': lambda: func.HA(open_, high, low, close)[0], + 'RVI': lambda: func.RVI(close), } @@ -118,7 +129,7 @@ def test_unstable_period_moves_its_own_function(name): talib.set_unstable_period(name, 0) unshifted = call() baseline = _leading_unset(unshifted) - assert baseline > 0, 'nothing to shift' + assert baseline > 0 or name == 'HA' # HA is the one case with no lookback try: talib.set_unstable_period(name, 5) shifted = call() @@ -293,3 +304,54 @@ def test_MAXINDEX(): d = np.array([1., 2, 3]) e = func.MAXINDEX(d, 10) assert_array_equal(e, [0,0,0]) + + +# The func API bakes each parameter's default into its own signature, while the +# abstract API reads them from the library. They have to agree, for all 201. +def test_func_and_abstract_agree(): + n = 200 + rs = np.random.RandomState(4) + close = np.cumsum(rs.randn(n)) + 100.0 + inputs = { + 'open': close + rs.rand(n) - 0.5, + 'high': close + rs.rand(n) + 0.5, + 'low': close - rs.rand(n) - 0.5, + 'close': close, + 'volume': rs.rand(n) * 1e6 + 1e5, + 'real': close, + 'real0': close, + 'real1': close + rs.rand(n), + 'periods': np.full(n, 10.0), + } + for name in talib.__TA_FUNCTION_NAMES__: + function = abstract.Function(name) + args = [] + for series in function.input_names.values(): + args += [inputs[s] for s in series] if isinstance(series, list) else [inputs[series]] + got = getattr(func, name)(*args) + want = function(inputs) + got = list(got) if isinstance(got, tuple) else [got] + want = want if isinstance(want, list) else [want] + assert len(got) == len(want), name + for a, b in zip(got, want): + assert len(a) == n, name + assert_array_equal(a, b, err_msg=name) + + +# The moving averages TA-Lib C 0.8.1 added to TA_MAType. +@pytest.mark.parametrize('matype,name', [ + (talib.MA_Type.HMA, 'HMA'), + (talib.MA_Type.ZLEMA, 'ZLEMA'), + (talib.MA_Type.RMA, 'RMA'), +]) +def test_MA_dispatches_to_the_new_types(matype, name): + a = np.cumsum(np.random.RandomState(3).randn(200)) + 100.0 + assert_array_equal(func.MA(a, 20, matype), getattr(func, name)(a, 20)) + + +def test_MA_DISABLED_and_DEFAULT(): + a = np.cumsum(np.random.RandomState(3).randn(200)) + 100.0 + assert_array_equal(func.MA(a, 20, talib.MA_Type.DISABLED), a) + # MA's own default is SMA, so it cannot tell DEFAULT from SMA. APO's is EMA. + assert_array_equal(func.APO(a, matype=talib.MA_Type.DEFAULT), + func.APO(a, matype=talib.MA_Type.EMA)) diff --git a/tests/test_stubs.py b/tests/test_stubs.py new file mode 100644 index 000000000..6c47e8d36 --- /dev/null +++ b/tests/test_stubs.py @@ -0,0 +1,27 @@ +import ast +import os + +import talib + +STUBS = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'talib') + + +def _stub(name): + with open(os.path.join(STUBS, name)) as f: + return f.read() + + +# The stubs ship as package data beside py.typed, and nothing else in the build +# reads them, so a broken one reaches every downstream type checker in silence. +def test_stubs_parse(): + for name in ('_ta_lib.pyi', 'abstract.pyi'): + ast.parse(_stub(name), filename=name) + + +def test_stubs_cover_every_function(): + stub = _stub('_ta_lib.pyi') + declared = {node.name for node in ast.parse(stub).body + if isinstance(node, ast.FunctionDef)} + for name in talib.__TA_FUNCTION_NAMES__: + assert name in declared, name + assert 'stream_%s' % name in declared, name diff --git a/tools/build_talib_linux.sh b/tools/build_talib_linux.sh index 361519c34..fd00a2201 100644 --- a/tools/build_talib_linux.sh +++ b/tools/build_talib_linux.sh @@ -1,6 +1,6 @@ #!/bin/bash -TALIB_C_VER="${TALIB_C_VER:=0.7.1}" +TALIB_C_VER="${TALIB_C_VER:=0.8.1}" CMAKE_GENERATOR="Unix Makefiles" CMAKE_BUILD_TYPE=Release CMAKE_CONFIGURATION_TYPES=Release diff --git a/tools/build_talib_macos.sh b/tools/build_talib_macos.sh index 361519c34..fd00a2201 100644 --- a/tools/build_talib_macos.sh +++ b/tools/build_talib_macos.sh @@ -1,6 +1,6 @@ #!/bin/bash -TALIB_C_VER="${TALIB_C_VER:=0.7.1}" +TALIB_C_VER="${TALIB_C_VER:=0.8.1}" CMAKE_GENERATOR="Unix Makefiles" CMAKE_BUILD_TYPE=Release CMAKE_CONFIGURATION_TYPES=Release diff --git a/tools/build_talib_windows.cmd b/tools/build_talib_windows.cmd index 187009e75..4efc18df4 100644 --- a/tools/build_talib_windows.cmd +++ b/tools/build_talib_windows.cmd @@ -1,7 +1,7 @@ :: Download and build TA-Lib @echo on -if not defined TALIB_C_VER set TALIB_C_VER=0.7.1 +if not defined TALIB_C_VER set TALIB_C_VER=0.8.1 set CMAKE_GENERATOR=NMake Makefiles set CMAKE_BUILD_TYPE=Release diff --git a/tools/generate_func.py b/tools/generate_func.py index 6dbb4b100..394e4a5d4 100644 --- a/tools/generate_func.py +++ b/tools/generate_func.py @@ -61,6 +61,10 @@ functions = [s for s in functions if not s.startswith('TA_RetCode TA_Set')] functions = [s for s in functions if not s.startswith('TA_RetCode TA_Restore')] +# strip TA-Lib C's own streaming API (ta-lib >= 0.8.1). Those declarations take +# an opaque TA__Stream handle, not the batch argument shape parsed below. +functions = [s for s in functions if '_Stream' not in s] + # print headers print("""\ cimport numpy as np @@ -275,7 +279,9 @@ def cleanup(name): else: print('int %s=-2**31' % var, end=' ') # TA_INTEGER_DEFAULT elif arg.startswith('TA_MAType'): - print('int %s=%s' % (var, defaults.get('matype', 0)), end=' ') # TA_MAType_SMA + # abstract lowercases the whole name, and a prefixed one (KDJ's + # slowk_matype) is not spelled 'matype'. + print('int %s=%s' % (var, defaults.get(default_arg.lower(), 11)), end=' ') # TA_MAType_DEFAULT else: assert False, arg if '[, ' not in docs: diff --git a/tools/generate_stream.py b/tools/generate_stream.py index 7d6af3f68..4688b94b9 100644 --- a/tools/generate_stream.py +++ b/tools/generate_stream.py @@ -61,6 +61,10 @@ functions = [s for s in functions if not s.startswith('TA_RetCode TA_Set')] functions = [s for s in functions if not s.startswith('TA_RetCode TA_Restore')] +# strip TA-Lib C's own streaming API (ta-lib >= 0.8.1). Those declarations take +# an opaque TA__Stream handle, not the batch argument shape parsed below. +functions = [s for s in functions if '_Stream' not in s] + # print headers print("""\ cimport numpy as np @@ -142,7 +146,9 @@ def cleanup(name): else: print('int %s=-2**31' % var, end=' ') # TA_INTEGER_DEFAULT elif arg.startswith('TA_MAType'): - print('int %s=%s' % (var, defaults.get('matype', 0)), end=' ') # TA_MAType_SMA + # abstract lowercases the whole name, and a prefixed one (KDJ's + # slowk_matype) is not spelled 'matype'. + print('int %s=%s' % (var, defaults.get(default_arg.lower(), 11)), end=' ') # TA_MAType_DEFAULT else: assert False, arg if '[, ' not in docs: