polars_ta.talib

直接调用TA-Lib, 多输出时返回struct, 可以使用.struct[0]取到对应字段的Series.

polars_ta.talib

Functions:

Name	Description
ACOS	ACOS(ndarray real)
AD	AD(ndarray high, ndarray low, ndarray close, ndarray volume)
ADD	ADD(ndarray real0, ndarray real1)
ADOSC	ADOSC(ndarray high, ndarray low, ndarray close, ndarray volume, int fastperiod=-0x80000000, int slowperiod=-0x80000000)
ADX	ADX(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)
ADXR	ADXR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)
APO	APO(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int matype=0)
AROON	AROON(ndarray high, ndarray low, int timeperiod=-0x80000000)
AROONOSC	AROONOSC(ndarray high, ndarray low, int timeperiod=-0x80000000)
ASIN	ASIN(ndarray real)
ATAN	ATAN(ndarray real)
ATR	ATR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)
AVGPRICE	AVGPRICE(ndarray open, ndarray high, ndarray low, ndarray close)
BBANDS	BBANDS(ndarray real, int timeperiod=-0x80000000, double nbdevup=-4e37, double nbdevdn=-4e37, int matype=0)
BETA	BETA(ndarray real0, ndarray real1, int timeperiod=-0x80000000)
BOP	BOP(ndarray open, ndarray high, ndarray low, ndarray close)
CCI	CCI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)
CDL2CROWS	CDL2CROWS(ndarray open, ndarray high, ndarray low, ndarray close)
CDL3BLACKCROWS	CDL3BLACKCROWS(ndarray open, ndarray high, ndarray low, ndarray close)
CDL3INSIDE	CDL3INSIDE(ndarray open, ndarray high, ndarray low, ndarray close)
CDL3LINESTRIKE	CDL3LINESTRIKE(ndarray open, ndarray high, ndarray low, ndarray close)
CDL3OUTSIDE	CDL3OUTSIDE(ndarray open, ndarray high, ndarray low, ndarray close)
CDL3STARSINSOUTH	CDL3STARSINSOUTH(ndarray open, ndarray high, ndarray low, ndarray close)
CDL3WHITESOLDIERS	CDL3WHITESOLDIERS(ndarray open, ndarray high, ndarray low, ndarray close)
CDLABANDONEDBABY	CDLABANDONEDBABY(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)
CDLADVANCEBLOCK	CDLADVANCEBLOCK(ndarray open, ndarray high, ndarray low, ndarray close)
CDLBELTHOLD	CDLBELTHOLD(ndarray open, ndarray high, ndarray low, ndarray close)
CDLBREAKAWAY	CDLBREAKAWAY(ndarray open, ndarray high, ndarray low, ndarray close)
CDLCLOSINGMARUBOZU	CDLCLOSINGMARUBOZU(ndarray open, ndarray high, ndarray low, ndarray close)
CDLCONCEALBABYSWALL	CDLCONCEALBABYSWALL(ndarray open, ndarray high, ndarray low, ndarray close)
CDLCOUNTERATTACK	CDLCOUNTERATTACK(ndarray open, ndarray high, ndarray low, ndarray close)
CDLDARKCLOUDCOVER	CDLDARKCLOUDCOVER(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.5)
CDLDOJI	CDLDOJI(ndarray open, ndarray high, ndarray low, ndarray close)
CDLDOJISTAR	CDLDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close)
CDLDRAGONFLYDOJI	CDLDRAGONFLYDOJI(ndarray open, ndarray high, ndarray low, ndarray close)
CDLENGULFING	CDLENGULFING(ndarray open, ndarray high, ndarray low, ndarray close)
CDLEVENINGDOJISTAR	CDLEVENINGDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)
CDLEVENINGSTAR	CDLEVENINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)
CDLGAPSIDESIDEWHITE	CDLGAPSIDESIDEWHITE(ndarray open, ndarray high, ndarray low, ndarray close)
CDLGRAVESTONEDOJI	CDLGRAVESTONEDOJI(ndarray open, ndarray high, ndarray low, ndarray close)
CDLHAMMER	CDLHAMMER(ndarray open, ndarray high, ndarray low, ndarray close)
CDLHANGINGMAN	CDLHANGINGMAN(ndarray open, ndarray high, ndarray low, ndarray close)
CDLHARAMI	CDLHARAMI(ndarray open, ndarray high, ndarray low, ndarray close)
CDLHARAMICROSS	CDLHARAMICROSS(ndarray open, ndarray high, ndarray low, ndarray close)
CDLHIGHWAVE	CDLHIGHWAVE(ndarray open, ndarray high, ndarray low, ndarray close)
CDLHIKKAKE	CDLHIKKAKE(ndarray open, ndarray high, ndarray low, ndarray close)
CDLHIKKAKEMOD	CDLHIKKAKEMOD(ndarray open, ndarray high, ndarray low, ndarray close)
CDLHOMINGPIGEON	CDLHOMINGPIGEON(ndarray open, ndarray high, ndarray low, ndarray close)
CDLIDENTICAL3CROWS	CDLIDENTICAL3CROWS(ndarray open, ndarray high, ndarray low, ndarray close)
CDLINNECK	CDLINNECK(ndarray open, ndarray high, ndarray low, ndarray close)
CDLINVERTEDHAMMER	CDLINVERTEDHAMMER(ndarray open, ndarray high, ndarray low, ndarray close)
CDLKICKING	CDLKICKING(ndarray open, ndarray high, ndarray low, ndarray close)
CDLKICKINGBYLENGTH	CDLKICKINGBYLENGTH(ndarray open, ndarray high, ndarray low, ndarray close)
CDLLADDERBOTTOM	CDLLADDERBOTTOM(ndarray open, ndarray high, ndarray low, ndarray close)
CDLLONGLEGGEDDOJI	CDLLONGLEGGEDDOJI(ndarray open, ndarray high, ndarray low, ndarray close)
CDLLONGLINE	CDLLONGLINE(ndarray open, ndarray high, ndarray low, ndarray close)
CDLMARUBOZU	CDLMARUBOZU(ndarray open, ndarray high, ndarray low, ndarray close)
CDLMATCHINGLOW	CDLMATCHINGLOW(ndarray open, ndarray high, ndarray low, ndarray close)
CDLMATHOLD	CDLMATHOLD(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.5)
CDLMORNINGDOJISTAR	CDLMORNINGDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)
CDLMORNINGSTAR	CDLMORNINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)
CDLONNECK	CDLONNECK(ndarray open, ndarray high, ndarray low, ndarray close)
CDLPIERCING	CDLPIERCING(ndarray open, ndarray high, ndarray low, ndarray close)
CDLRICKSHAWMAN	CDLRICKSHAWMAN(ndarray open, ndarray high, ndarray low, ndarray close)
CDLRISEFALL3METHODS	CDLRISEFALL3METHODS(ndarray open, ndarray high, ndarray low, ndarray close)
CDLSEPARATINGLINES	CDLSEPARATINGLINES(ndarray open, ndarray high, ndarray low, ndarray close)
CDLSHOOTINGSTAR	CDLSHOOTINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close)
CDLSHORTLINE	CDLSHORTLINE(ndarray open, ndarray high, ndarray low, ndarray close)
CDLSPINNINGTOP	CDLSPINNINGTOP(ndarray open, ndarray high, ndarray low, ndarray close)
CDLSTALLEDPATTERN	CDLSTALLEDPATTERN(ndarray open, ndarray high, ndarray low, ndarray close)
CDLSTICKSANDWICH	CDLSTICKSANDWICH(ndarray open, ndarray high, ndarray low, ndarray close)
CDLTAKURI	CDLTAKURI(ndarray open, ndarray high, ndarray low, ndarray close)
CDLTASUKIGAP	CDLTASUKIGAP(ndarray open, ndarray high, ndarray low, ndarray close)
CDLTHRUSTING	CDLTHRUSTING(ndarray open, ndarray high, ndarray low, ndarray close)
CDLTRISTAR	CDLTRISTAR(ndarray open, ndarray high, ndarray low, ndarray close)
CDLUNIQUE3RIVER	CDLUNIQUE3RIVER(ndarray open, ndarray high, ndarray low, ndarray close)
CDLUPSIDEGAP2CROWS	CDLUPSIDEGAP2CROWS(ndarray open, ndarray high, ndarray low, ndarray close)
CDLXSIDEGAP3METHODS	CDLXSIDEGAP3METHODS(ndarray open, ndarray high, ndarray low, ndarray close)
CEIL	CEIL(ndarray real)
CMO	CMO(ndarray real, int timeperiod=-0x80000000)
CORREL	CORREL(ndarray real0, ndarray real1, int timeperiod=-0x80000000)
COS	COS(ndarray real)
COSH	COSH(ndarray real)
DEMA	DEMA(ndarray real, int timeperiod=-0x80000000)
DIV	DIV(ndarray real0, ndarray real1)
DX	DX(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)
EMA	EMA(ndarray real, int timeperiod=-0x80000000)
EXP	EXP(ndarray real)
FLOOR	FLOOR(ndarray real)
HT_DCPERIOD	HT_DCPERIOD(ndarray real)
HT_DCPHASE	HT_DCPHASE(ndarray real)
HT_PHASOR	HT_PHASOR(ndarray real)
HT_SINE	HT_SINE(ndarray real)
HT_TRENDLINE	HT_TRENDLINE(ndarray real)
HT_TRENDMODE	HT_TRENDMODE(ndarray real)
KAMA	KAMA(ndarray real, int timeperiod=-0x80000000)
LINEARREG	LINEARREG(ndarray real, int timeperiod=-0x80000000)
LINEARREG_ANGLE	LINEARREG_ANGLE(ndarray real, int timeperiod=-0x80000000)
LINEARREG_INTERCEPT	LINEARREG_INTERCEPT(ndarray real, int timeperiod=-0x80000000)
LINEARREG_SLOPE	LINEARREG_SLOPE(ndarray real, int timeperiod=-0x80000000)
LN	LN(ndarray real)
LOG10	LOG10(ndarray real)
MA	MA(ndarray real, int timeperiod=-0x80000000, int matype=0)
MACD	MACD(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int signalperiod=-0x80000000)
MACDEXT	MACDEXT(ndarray real, int fastperiod=-0x80000000, int fastmatype=0, int slowperiod=-0x80000000, int slowmatype=0, int signalperiod=-0x80000000, int signalmatype=0)
MACDFIX	MACDFIX(ndarray real, int signalperiod=-0x80000000)
MAMA	MAMA(ndarray real, double fastlimit=-4e37, double slowlimit=-4e37)
MAVP	MAVP(ndarray real, ndarray periods, int minperiod=-0x80000000, int maxperiod=-0x80000000, int matype=0)
MAX	MAX(ndarray real, int timeperiod=-0x80000000)
MAXINDEX	MAXINDEX(ndarray real, int timeperiod=-0x80000000)
MEDPRICE	MEDPRICE(ndarray high, ndarray low)
MFI	MFI(ndarray high, ndarray low, ndarray close, ndarray volume, int timeperiod=-0x80000000)
MIDPOINT	MIDPOINT(ndarray real, int timeperiod=-0x80000000)
MIDPRICE	MIDPRICE(ndarray high, ndarray low, int timeperiod=-0x80000000)
MIN	MIN(ndarray real, int timeperiod=-0x80000000)
MININDEX	MININDEX(ndarray real, int timeperiod=-0x80000000)
MINMAX	MINMAX(ndarray real, int timeperiod=-0x80000000)
MINMAXINDEX	MINMAXINDEX(ndarray real, int timeperiod=-0x80000000)
MINUS_DI	MINUS_DI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)
MINUS_DM	MINUS_DM(ndarray high, ndarray low, int timeperiod=-0x80000000)
MOM	MOM(ndarray real, int timeperiod=-0x80000000)
MULT	MULT(ndarray real0, ndarray real1)
NATR	NATR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)
OBV	OBV(ndarray real, ndarray volume)
PLUS_DI	PLUS_DI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)
PLUS_DM	PLUS_DM(ndarray high, ndarray low, int timeperiod=-0x80000000)
PPO	PPO(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int matype=0)
ROC	ROC(ndarray real, int timeperiod=-0x80000000)
ROCP	ROCP(ndarray real, int timeperiod=-0x80000000)
ROCR	ROCR(ndarray real, int timeperiod=-0x80000000)
ROCR100	ROCR100(ndarray real, int timeperiod=-0x80000000)
RSI	RSI(ndarray real, int timeperiod=-0x80000000)
SAR	SAR(ndarray high, ndarray low, double acceleration=0.02, double maximum=0.2)
SAREXT	SAREXT(ndarray high, ndarray low, double startvalue=-4e37, double offsetonreverse=-4e37, double accelerationinitlong=-4e37, double accelerationlong=-4e37, double accelerationmaxlong=-4e37, double accelerationinitshort=-4e37, double accelerationshort=-4e37, double accelerationmaxshort=-4e37)
SIN	SIN(ndarray real)
SINH	SINH(ndarray real)
SMA	SMA(ndarray real, int timeperiod=-0x80000000)
SQRT	SQRT(ndarray real)
STDDEV	STDDEV(ndarray real, int timeperiod=-0x80000000, double nbdev=-4e37)
STOCH	STOCH(ndarray high, ndarray low, ndarray close, int fastk_period=-0x80000000, int slowk_period=-0x80000000, int slowk_matype=0, int slowd_period=-0x80000000, int slowd_matype=0)
STOCHF	STOCHF(ndarray high, ndarray low, ndarray close, int fastk_period=-0x80000000, int fastd_period=-0x80000000, int fastd_matype=0)
STOCHRSI	STOCHRSI(ndarray real, int timeperiod=-0x80000000, int fastk_period=-0x80000000, int fastd_period=-0x80000000, int fastd_matype=0)
SUB	SUB(ndarray real0, ndarray real1)
SUM	SUM(ndarray real, int timeperiod=-0x80000000)
T3	T3(ndarray real, int timeperiod=-0x80000000, double vfactor=-4e37)
TAN	TAN(ndarray real)
TANH	TANH(ndarray real)
TEMA	TEMA(ndarray real, int timeperiod=-0x80000000)
TRANGE	TRANGE(ndarray high, ndarray low, ndarray close)
TRIMA	TRIMA(ndarray real, int timeperiod=-0x80000000)
TRIX	TRIX(ndarray real, int timeperiod=-0x80000000)
TSF	TSF(ndarray real, int timeperiod=-0x80000000)
TYPPRICE	TYPPRICE(ndarray high, ndarray low, ndarray close)
ULTOSC	ULTOSC(ndarray high, ndarray low, ndarray close, int timeperiod1=-0x80000000, int timeperiod2=-0x80000000, int timeperiod3=-0x80000000)
VAR	VAR(ndarray real, int timeperiod=-0x80000000, double nbdev=-4e37)
WCLPRICE	WCLPRICE(ndarray high, ndarray low, ndarray close)
WILLR	WILLR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)
WMA	WMA(ndarray real, int timeperiod=-0x80000000)

ACOS(close: Expr) -> Expr

ACOS(ndarray real)

ACOS(real)

Vector Trigonometric ACos (Math Transform)

Inputs: real: (any ndarray) Outputs: real

AD(high: Expr, low: Expr, close: Expr, volume: Expr) -> Expr

AD(ndarray high, ndarray low, ndarray close, ndarray volume)

AD(high, low, close, volume)

Chaikin A/D Line (Volume Indicators)

Inputs: prices: ['high', 'low', 'close', 'volume'] Outputs: real

ADD(high: Expr, low: Expr) -> Expr

ADD(ndarray real0, ndarray real1)

ADD(real0, real1)

Vector Arithmetic Add (Math Operators)

Inputs: real0: (any ndarray) real1: (any ndarray) Outputs: real

ADOSC(high: Expr, low: Expr, close: Expr, volume: Expr, fastperiod: float = 3.0, slowperiod: float = 10.0) -> Expr

ADOSC(ndarray high, ndarray low, ndarray close, ndarray volume, int fastperiod=-0x80000000, int slowperiod=-0x80000000)

ADOSC(high, low, close, volume[, fastperiod=?, slowperiod=?])

Chaikin A/D Oscillator (Volume Indicators)

Inputs: prices: ['high', 'low', 'close', 'volume'] Parameters: fastperiod: 3 slowperiod: 10 Outputs: real

ADX(high: Expr, low: Expr, close: Expr, timeperiod: float = 14.0) -> Expr

ADX(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)

ADX(high, low, close[, timeperiod=?])

Average Directional Movement Index (Momentum Indicators)

Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real

ADXR(high: Expr, low: Expr, close: Expr, timeperiod: float = 14.0) -> Expr

ADXR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)

ADXR(high, low, close[, timeperiod=?])

Average Directional Movement Index Rating (Momentum Indicators)

Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real

APO(close: Expr, fastperiod: float = 12.0, slowperiod: float = 26.0, matype: float = 0.0) -> Expr

APO(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int matype=0)

APO(real[, fastperiod=?, slowperiod=?, matype=?])

Absolute Price Oscillator (Momentum Indicators)

Inputs: real: (any ndarray) Parameters: fastperiod: 12 slowperiod: 26 matype: 0 (Simple Moving Average) Outputs: real

AROON(high: Expr, low: Expr, timeperiod: float = 14.0) -> Expr

AROON(ndarray high, ndarray low, int timeperiod=-0x80000000)

AROON(high, low[, timeperiod=?])

Aroon (Momentum Indicators)

Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: aroondown aroonup

AROONOSC(high: Expr, low: Expr, timeperiod: float = 14.0) -> Expr

AROONOSC(ndarray high, ndarray low, int timeperiod=-0x80000000)

AROONOSC(high, low[, timeperiod=?])

Aroon Oscillator (Momentum Indicators)

Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: real

ASIN(close: Expr) -> Expr

ASIN(ndarray real)

ASIN(real)

Vector Trigonometric ASin (Math Transform)

Inputs: real: (any ndarray) Outputs: real

ATAN(close: Expr) -> Expr

ATAN(ndarray real)

ATAN(real)

Vector Trigonometric ATan (Math Transform)

Inputs: real: (any ndarray) Outputs: real

ATR(high: Expr, low: Expr, close: Expr, timeperiod: float = 14.0) -> Expr

ATR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)

ATR(high, low, close[, timeperiod=?])

Average True Range (Volatility Indicators)

Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real

AVGPRICE(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

AVGPRICE(ndarray open, ndarray high, ndarray low, ndarray close)

AVGPRICE(open, high, low, close)

Average Price (Price Transform)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: real

BBANDS(close: Expr, timeperiod: float = 5.0, nbdevup: float = 2.0, nbdevdn: float = 2.0, matype: float = 0.0) -> Expr

BBANDS(ndarray real, int timeperiod=-0x80000000, double nbdevup=-4e37, double nbdevdn=-4e37, int matype=0)

BBANDS(real[, timeperiod=?, nbdevup=?, nbdevdn=?, matype=?])

Bollinger Bands (Overlap Studies)

Inputs: real: (any ndarray) Parameters: timeperiod: 5 nbdevup: 2.0 nbdevdn: 2.0 matype: 0 (Simple Moving Average) Outputs: upperband middleband lowerband

BETA(high: Expr, low: Expr, timeperiod: float = 5.0) -> Expr

BETA(ndarray real0, ndarray real1, int timeperiod=-0x80000000)

BETA(real0, real1[, timeperiod=?])

Beta (Statistic Functions)

Inputs: real0: (any ndarray) real1: (any ndarray) Parameters: timeperiod: 5 Outputs: real

BOP(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

BOP(ndarray open, ndarray high, ndarray low, ndarray close)

BOP(open, high, low, close)

Balance Of Power (Momentum Indicators)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: real

CCI(high: Expr, low: Expr, close: Expr, timeperiod: float = 14.0) -> Expr

CCI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)

CCI(high, low, close[, timeperiod=?])

Commodity Channel Index (Momentum Indicators)

Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real

CDL2CROWS(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDL2CROWS(ndarray open, ndarray high, ndarray low, ndarray close)

CDL2CROWS(open, high, low, close)

Two Crows (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDL3BLACKCROWS(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDL3BLACKCROWS(ndarray open, ndarray high, ndarray low, ndarray close)

CDL3BLACKCROWS(open, high, low, close)

Three Black Crows (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDL3INSIDE(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDL3INSIDE(ndarray open, ndarray high, ndarray low, ndarray close)

CDL3INSIDE(open, high, low, close)

Three Inside Up/Down (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDL3LINESTRIKE(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDL3LINESTRIKE(ndarray open, ndarray high, ndarray low, ndarray close)

CDL3LINESTRIKE(open, high, low, close)

Three-Line Strike (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDL3OUTSIDE(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDL3OUTSIDE(ndarray open, ndarray high, ndarray low, ndarray close)

CDL3OUTSIDE(open, high, low, close)

Three Outside Up/Down (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDL3STARSINSOUTH(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDL3STARSINSOUTH(ndarray open, ndarray high, ndarray low, ndarray close)

CDL3STARSINSOUTH(open, high, low, close)

Three Stars In The South (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDL3WHITESOLDIERS(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDL3WHITESOLDIERS(ndarray open, ndarray high, ndarray low, ndarray close)

CDL3WHITESOLDIERS(open, high, low, close)

Three Advancing White Soldiers (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLABANDONEDBABY(open: Expr, high: Expr, low: Expr, close: Expr, penetration: float = 0.3) -> Expr

CDLABANDONEDBABY(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)

CDLABANDONEDBABY(open, high, low, close[, penetration=?])

Abandoned Baby (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100)

CDLADVANCEBLOCK(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLADVANCEBLOCK(ndarray open, ndarray high, ndarray low, ndarray close)

CDLADVANCEBLOCK(open, high, low, close)

Advance Block (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLBELTHOLD(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLBELTHOLD(ndarray open, ndarray high, ndarray low, ndarray close)

CDLBELTHOLD(open, high, low, close)

Belt-hold (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLBREAKAWAY(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLBREAKAWAY(ndarray open, ndarray high, ndarray low, ndarray close)

CDLBREAKAWAY(open, high, low, close)

Breakaway (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLCLOSINGMARUBOZU(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLCLOSINGMARUBOZU(ndarray open, ndarray high, ndarray low, ndarray close)

CDLCLOSINGMARUBOZU(open, high, low, close)

Closing Marubozu (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLCONCEALBABYSWALL(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLCONCEALBABYSWALL(ndarray open, ndarray high, ndarray low, ndarray close)

CDLCONCEALBABYSWALL(open, high, low, close)

Concealing Baby Swallow (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLCOUNTERATTACK(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLCOUNTERATTACK(ndarray open, ndarray high, ndarray low, ndarray close)

CDLCOUNTERATTACK(open, high, low, close)

Counterattack (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLDARKCLOUDCOVER(open: Expr, high: Expr, low: Expr, close: Expr, penetration: float = 0.5) -> Expr

CDLDARKCLOUDCOVER(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.5)

CDLDARKCLOUDCOVER(open, high, low, close[, penetration=?])

Dark Cloud Cover (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.5 Outputs: integer (values are -100, 0 or 100)

CDLDOJI(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLDOJI(ndarray open, ndarray high, ndarray low, ndarray close)

CDLDOJI(open, high, low, close)

Doji (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLDOJISTAR(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close)

CDLDOJISTAR(open, high, low, close)

Doji Star (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLDRAGONFLYDOJI(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLDRAGONFLYDOJI(ndarray open, ndarray high, ndarray low, ndarray close)

CDLDRAGONFLYDOJI(open, high, low, close)

Dragonfly Doji (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLENGULFING(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLENGULFING(ndarray open, ndarray high, ndarray low, ndarray close)

CDLENGULFING(open, high, low, close)

Engulfing Pattern (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLEVENINGDOJISTAR(open: Expr, high: Expr, low: Expr, close: Expr, penetration: float = 0.3) -> Expr

CDLEVENINGDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)

CDLEVENINGDOJISTAR(open, high, low, close[, penetration=?])

Evening Doji Star (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100)

CDLEVENINGSTAR(open: Expr, high: Expr, low: Expr, close: Expr, penetration: float = 0.3) -> Expr

CDLEVENINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)

CDLEVENINGSTAR(open, high, low, close[, penetration=?])

Evening Star (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100)

CDLGAPSIDESIDEWHITE(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLGAPSIDESIDEWHITE(ndarray open, ndarray high, ndarray low, ndarray close)

CDLGAPSIDESIDEWHITE(open, high, low, close)

Up/Down-gap side-by-side white lines (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLGRAVESTONEDOJI(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLGRAVESTONEDOJI(ndarray open, ndarray high, ndarray low, ndarray close)

CDLGRAVESTONEDOJI(open, high, low, close)

Gravestone Doji (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLHAMMER(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLHAMMER(ndarray open, ndarray high, ndarray low, ndarray close)

CDLHAMMER(open, high, low, close)

Hammer (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLHANGINGMAN(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLHANGINGMAN(ndarray open, ndarray high, ndarray low, ndarray close)

CDLHANGINGMAN(open, high, low, close)

Hanging Man (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLHARAMI(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLHARAMI(ndarray open, ndarray high, ndarray low, ndarray close)

CDLHARAMI(open, high, low, close)

Harami Pattern (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLHARAMICROSS(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLHARAMICROSS(ndarray open, ndarray high, ndarray low, ndarray close)

CDLHARAMICROSS(open, high, low, close)

Harami Cross Pattern (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLHIGHWAVE(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLHIGHWAVE(ndarray open, ndarray high, ndarray low, ndarray close)

CDLHIGHWAVE(open, high, low, close)

High-Wave Candle (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLHIKKAKE(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLHIKKAKE(ndarray open, ndarray high, ndarray low, ndarray close)

CDLHIKKAKE(open, high, low, close)

Hikkake Pattern (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLHIKKAKEMOD(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLHIKKAKEMOD(ndarray open, ndarray high, ndarray low, ndarray close)

CDLHIKKAKEMOD(open, high, low, close)

Modified Hikkake Pattern (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLHOMINGPIGEON(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLHOMINGPIGEON(ndarray open, ndarray high, ndarray low, ndarray close)

CDLHOMINGPIGEON(open, high, low, close)

Homing Pigeon (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLIDENTICAL3CROWS(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLIDENTICAL3CROWS(ndarray open, ndarray high, ndarray low, ndarray close)

CDLIDENTICAL3CROWS(open, high, low, close)

Identical Three Crows (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLINNECK(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLINNECK(ndarray open, ndarray high, ndarray low, ndarray close)

CDLINNECK(open, high, low, close)

In-Neck Pattern (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLINVERTEDHAMMER(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLINVERTEDHAMMER(ndarray open, ndarray high, ndarray low, ndarray close)

CDLINVERTEDHAMMER(open, high, low, close)

Inverted Hammer (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLKICKING(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLKICKING(ndarray open, ndarray high, ndarray low, ndarray close)

CDLKICKING(open, high, low, close)

Kicking (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLKICKINGBYLENGTH(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLKICKINGBYLENGTH(ndarray open, ndarray high, ndarray low, ndarray close)

CDLKICKINGBYLENGTH(open, high, low, close)

Kicking - bull/bear determined by the longer marubozu (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLLADDERBOTTOM(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLLADDERBOTTOM(ndarray open, ndarray high, ndarray low, ndarray close)

CDLLADDERBOTTOM(open, high, low, close)

Ladder Bottom (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLLONGLEGGEDDOJI(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLLONGLEGGEDDOJI(ndarray open, ndarray high, ndarray low, ndarray close)

CDLLONGLEGGEDDOJI(open, high, low, close)

Long Legged Doji (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLLONGLINE(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLLONGLINE(ndarray open, ndarray high, ndarray low, ndarray close)

CDLLONGLINE(open, high, low, close)

Long Line Candle (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLMARUBOZU(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLMARUBOZU(ndarray open, ndarray high, ndarray low, ndarray close)

CDLMARUBOZU(open, high, low, close)

Marubozu (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLMATCHINGLOW(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLMATCHINGLOW(ndarray open, ndarray high, ndarray low, ndarray close)

CDLMATCHINGLOW(open, high, low, close)

Matching Low (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLMATHOLD(open: Expr, high: Expr, low: Expr, close: Expr, penetration: float = 0.5) -> Expr

CDLMATHOLD(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.5)

CDLMATHOLD(open, high, low, close[, penetration=?])

Mat Hold (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.5 Outputs: integer (values are -100, 0 or 100)

CDLMORNINGDOJISTAR(open: Expr, high: Expr, low: Expr, close: Expr, penetration: float = 0.3) -> Expr

CDLMORNINGDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)

CDLMORNINGDOJISTAR(open, high, low, close[, penetration=?])

Morning Doji Star (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100)

CDLMORNINGSTAR(open: Expr, high: Expr, low: Expr, close: Expr, penetration: float = 0.3) -> Expr

CDLMORNINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)

CDLMORNINGSTAR(open, high, low, close[, penetration=?])

Morning Star (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100)

CDLONNECK(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLONNECK(ndarray open, ndarray high, ndarray low, ndarray close)

CDLONNECK(open, high, low, close)

On-Neck Pattern (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLPIERCING(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLPIERCING(ndarray open, ndarray high, ndarray low, ndarray close)

CDLPIERCING(open, high, low, close)

Piercing Pattern (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLRICKSHAWMAN(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLRICKSHAWMAN(ndarray open, ndarray high, ndarray low, ndarray close)

CDLRICKSHAWMAN(open, high, low, close)

Rickshaw Man (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLRISEFALL3METHODS(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLRISEFALL3METHODS(ndarray open, ndarray high, ndarray low, ndarray close)

CDLRISEFALL3METHODS(open, high, low, close)

Rising/Falling Three Methods (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLSEPARATINGLINES(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLSEPARATINGLINES(ndarray open, ndarray high, ndarray low, ndarray close)

CDLSEPARATINGLINES(open, high, low, close)

Separating Lines (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLSHOOTINGSTAR(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLSHOOTINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close)

CDLSHOOTINGSTAR(open, high, low, close)

Shooting Star (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLSHORTLINE(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLSHORTLINE(ndarray open, ndarray high, ndarray low, ndarray close)

CDLSHORTLINE(open, high, low, close)

Short Line Candle (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLSPINNINGTOP(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLSPINNINGTOP(ndarray open, ndarray high, ndarray low, ndarray close)

CDLSPINNINGTOP(open, high, low, close)

Spinning Top (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLSTALLEDPATTERN(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLSTALLEDPATTERN(ndarray open, ndarray high, ndarray low, ndarray close)

CDLSTALLEDPATTERN(open, high, low, close)

Stalled Pattern (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLSTICKSANDWICH(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLSTICKSANDWICH(ndarray open, ndarray high, ndarray low, ndarray close)

CDLSTICKSANDWICH(open, high, low, close)

Stick Sandwich (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLTAKURI(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLTAKURI(ndarray open, ndarray high, ndarray low, ndarray close)

CDLTAKURI(open, high, low, close)

Takuri (Dragonfly Doji with very long lower shadow) (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLTASUKIGAP(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLTASUKIGAP(ndarray open, ndarray high, ndarray low, ndarray close)

CDLTASUKIGAP(open, high, low, close)

Tasuki Gap (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLTHRUSTING(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLTHRUSTING(ndarray open, ndarray high, ndarray low, ndarray close)

CDLTHRUSTING(open, high, low, close)

Thrusting Pattern (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLTRISTAR(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLTRISTAR(ndarray open, ndarray high, ndarray low, ndarray close)

CDLTRISTAR(open, high, low, close)

Tristar Pattern (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLUNIQUE3RIVER(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLUNIQUE3RIVER(ndarray open, ndarray high, ndarray low, ndarray close)

CDLUNIQUE3RIVER(open, high, low, close)

Unique 3 River (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLUPSIDEGAP2CROWS(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLUPSIDEGAP2CROWS(ndarray open, ndarray high, ndarray low, ndarray close)

CDLUPSIDEGAP2CROWS(open, high, low, close)

Upside Gap Two Crows (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CDLXSIDEGAP3METHODS(open: Expr, high: Expr, low: Expr, close: Expr) -> Expr

CDLXSIDEGAP3METHODS(ndarray open, ndarray high, ndarray low, ndarray close)

CDLXSIDEGAP3METHODS(open, high, low, close)

Upside/Downside Gap Three Methods (Pattern Recognition)

Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)

CEIL(close: Expr) -> Expr

CEIL(ndarray real)

CEIL(real)

Vector Ceil (Math Transform)

Inputs: real: (any ndarray) Outputs: real

CMO(close: Expr, timeperiod: float = 14.0) -> Expr

CMO(ndarray real, int timeperiod=-0x80000000)

CMO(real[, timeperiod=?])

Chande Momentum Oscillator (Momentum Indicators)

Inputs: real: (any ndarray) Parameters: timeperiod: 14 Outputs: real

CORREL(high: Expr, low: Expr, timeperiod: float = 30.0) -> Expr

CORREL(ndarray real0, ndarray real1, int timeperiod=-0x80000000)

CORREL(real0, real1[, timeperiod=?])

Pearson's Correlation Coefficient (r) (Statistic Functions)

Inputs: real0: (any ndarray) real1: (any ndarray) Parameters: timeperiod: 30 Outputs: real

COS(close: Expr) -> Expr

COS(ndarray real)

COS(real)

Vector Trigonometric Cos (Math Transform)

Inputs: real: (any ndarray) Outputs: real

COSH(close: Expr) -> Expr

COSH(ndarray real)

COSH(real)

Vector Trigonometric Cosh (Math Transform)

Inputs: real: (any ndarray) Outputs: real

DEMA(close: Expr, timeperiod: float = 30.0) -> Expr

DEMA(ndarray real, int timeperiod=-0x80000000)

DEMA(real[, timeperiod=?])

Double Exponential Moving Average (Overlap Studies)

Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real

DIV(high: Expr, low: Expr) -> Expr

DIV(ndarray real0, ndarray real1)

DIV(real0, real1)

Vector Arithmetic Div (Math Operators)

Inputs: real0: (any ndarray) real1: (any ndarray) Outputs: real

DX(high: Expr, low: Expr, close: Expr, timeperiod: float = 14.0) -> Expr

DX(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)

DX(high, low, close[, timeperiod=?])

Directional Movement Index (Momentum Indicators)

Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real

EMA(close: Expr, timeperiod: float = 30.0) -> Expr

EMA(ndarray real, int timeperiod=-0x80000000)

EMA(real[, timeperiod=?])

Exponential Moving Average (Overlap Studies)

Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real

EXP(close: Expr) -> Expr

EXP(ndarray real)

EXP(real)

Vector Arithmetic Exp (Math Transform)

Inputs: real: (any ndarray) Outputs: real

FLOOR(close: Expr) -> Expr

FLOOR(ndarray real)

FLOOR(real)

Vector Floor (Math Transform)

Inputs: real: (any ndarray) Outputs: real

HT_DCPERIOD(close: Expr) -> Expr

HT_DCPERIOD(ndarray real)

HT_DCPERIOD(real)

Hilbert Transform - Dominant Cycle Period (Cycle Indicators)

Inputs: real: (any ndarray) Outputs: real

HT_DCPHASE(close: Expr) -> Expr

HT_DCPHASE(ndarray real)

HT_DCPHASE(real)

Hilbert Transform - Dominant Cycle Phase (Cycle Indicators)

Inputs: real: (any ndarray) Outputs: real

HT_PHASOR(close: Expr) -> Expr

HT_PHASOR(ndarray real)

HT_PHASOR(real)

Hilbert Transform - Phasor Components (Cycle Indicators)

Inputs: real: (any ndarray) Outputs: inphase quadrature

HT_SINE(close: Expr) -> Expr

HT_SINE(ndarray real)

HT_SINE(real)

Hilbert Transform - SineWave (Cycle Indicators)

Inputs: real: (any ndarray) Outputs: sine leadsine

HT_TRENDLINE(close: Expr) -> Expr

HT_TRENDLINE(ndarray real)

HT_TRENDLINE(real)

Hilbert Transform - Instantaneous Trendline (Overlap Studies)

Inputs: real: (any ndarray) Outputs: real

HT_TRENDMODE(close: Expr) -> Expr

HT_TRENDMODE(ndarray real)

HT_TRENDMODE(real)

Hilbert Transform - Trend vs Cycle Mode (Cycle Indicators)

Inputs: real: (any ndarray) Outputs: integer (values are -100, 0 or 100)

KAMA(close: Expr, timeperiod: float = 30.0) -> Expr

KAMA(ndarray real, int timeperiod=-0x80000000)

KAMA(real[, timeperiod=?])

Kaufman Adaptive Moving Average (Overlap Studies)

Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real

LINEARREG(close: Expr, timeperiod: float = 14.0) -> Expr

LINEARREG(ndarray real, int timeperiod=-0x80000000)

LINEARREG(real[, timeperiod=?])

Linear Regression (Statistic Functions)

Inputs: real: (any ndarray) Parameters: timeperiod: 14 Outputs: real

LINEARREG_ANGLE(close: Expr, timeperiod: float = 14.0) -> Expr

LINEARREG_ANGLE(ndarray real, int timeperiod=-0x80000000)

LINEARREG_ANGLE(real[, timeperiod=?])

Linear Regression Angle (Statistic Functions)

Inputs: real: (any ndarray) Parameters: timeperiod: 14 Outputs: real

LINEARREG_INTERCEPT(close: Expr, timeperiod: float = 14.0) -> Expr

LINEARREG_INTERCEPT(ndarray real, int timeperiod=-0x80000000)

LINEARREG_INTERCEPT(real[, timeperiod=?])

Linear Regression Intercept (Statistic Functions)

Inputs: real: (any ndarray) Parameters: timeperiod: 14 Outputs: real

LINEARREG_SLOPE(close: Expr, timeperiod: float = 14.0) -> Expr

LINEARREG_SLOPE(ndarray real, int timeperiod=-0x80000000)

LINEARREG_SLOPE(real[, timeperiod=?])

Linear Regression Slope (Statistic Functions)

Inputs: real: (any ndarray) Parameters: timeperiod: 14 Outputs: real

LN(close: Expr) -> Expr

LN(ndarray real)

LN(real)

Vector Log Natural (Math Transform)

Inputs: real: (any ndarray) Outputs: real

LOG10(close: Expr) -> Expr

LOG10(ndarray real)

LOG10(real)

Vector Log10 (Math Transform)

Inputs: real: (any ndarray) Outputs: real

MA(close: Expr, timeperiod: float = 30.0, matype: float = 0.0) -> Expr

MA(ndarray real, int timeperiod=-0x80000000, int matype=0)

MA(real[, timeperiod=?, matype=?])

Moving average (Overlap Studies)

Inputs: real: (any ndarray) Parameters: timeperiod: 30 matype: 0 (Simple Moving Average) Outputs: real

MACD(close: Expr, fastperiod: float = 12.0, slowperiod: float = 26.0, signalperiod: float = 9.0) -> Expr

MACD(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int signalperiod=-0x80000000)

MACD(real[, fastperiod=?, slowperiod=?, signalperiod=?])

Moving Average Convergence/Divergence (Momentum Indicators)

Inputs: real: (any ndarray) Parameters: fastperiod: 12 slowperiod: 26 signalperiod: 9 Outputs: macd macdsignal macdhist

MACDEXT(close: Expr, fastperiod: float = 12.0, fastmatype: float = 0.0, slowperiod: float = 26.0, slowmatype: float = 0.0, signalperiod: float = 9.0, signalmatype: float = 0.0) -> Expr

MACDEXT(ndarray real, int fastperiod=-0x80000000, int fastmatype=0, int slowperiod=-0x80000000, int slowmatype=0, int signalperiod=-0x80000000, int signalmatype=0)

MACDEXT(real[, fastperiod=?, fastmatype=?, slowperiod=?, slowmatype=?, signalperiod=?, signalmatype=?])

MACD with controllable MA type (Momentum Indicators)

Inputs: real: (any ndarray) Parameters: fastperiod: 12 fastmatype: 0 slowperiod: 26 slowmatype: 0 signalperiod: 9 signalmatype: 0 Outputs: macd macdsignal macdhist

MACDFIX(close: Expr, signalperiod: float = 9.0) -> Expr

MACDFIX(ndarray real, int signalperiod=-0x80000000)

MACDFIX(real[, signalperiod=?])

Moving Average Convergence/Divergence Fix 12/26 (Momentum Indicators)

Inputs: real: (any ndarray) Parameters: signalperiod: 9 Outputs: macd macdsignal macdhist

MAMA(close: Expr, fastlimit: float = 0.5, slowlimit: float = 0.05) -> Expr

MAMA(ndarray real, double fastlimit=-4e37, double slowlimit=-4e37)

MAMA(real[, fastlimit=?, slowlimit=?])

MESA Adaptive Moving Average (Overlap Studies)

Inputs: real: (any ndarray) Parameters: fastlimit: 0.5 slowlimit: 0.05 Outputs: mama fama

MAVP(close: Expr, periods: Expr, minperiod: float = 2.0, maxperiod: float = 30.0, matype: float = 0.0) -> Expr

MAVP(ndarray real, ndarray periods, int minperiod=-0x80000000, int maxperiod=-0x80000000, int matype=0)

MAVP(real, periods[, minperiod=?, maxperiod=?, matype=?])

Moving average with variable period (Overlap Studies)

Inputs: real: (any ndarray) periods: (any ndarray) Parameters: minperiod: 2 maxperiod: 30 matype: 0 (Simple Moving Average) Outputs: real

MAX(close: Expr, timeperiod: float = 30.0) -> Expr

MAX(ndarray real, int timeperiod=-0x80000000)

MAX(real[, timeperiod=?])

Highest value over a specified period (Math Operators)

Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real

MAXINDEX(close: Expr, timeperiod: float = 30.0) -> Expr

MAXINDEX(ndarray real, int timeperiod=-0x80000000)

MAXINDEX(real[, timeperiod=?])

Index of highest value over a specified period (Math Operators)

Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: integer (values are -100, 0 or 100)

MEDPRICE(high: Expr, low: Expr) -> Expr

MEDPRICE(ndarray high, ndarray low)

MEDPRICE(high, low)

Median Price (Price Transform)

Inputs: prices: ['high', 'low'] Outputs: real

MFI(high: Expr, low: Expr, close: Expr, volume: Expr, timeperiod: float = 14.0) -> Expr

MFI(ndarray high, ndarray low, ndarray close, ndarray volume, int timeperiod=-0x80000000)

MFI(high, low, close, volume[, timeperiod=?])

Money Flow Index (Momentum Indicators)

Inputs: prices: ['high', 'low', 'close', 'volume'] Parameters: timeperiod: 14 Outputs: real

MIDPOINT(close: Expr, timeperiod: float = 14.0) -> Expr

MIDPOINT(ndarray real, int timeperiod=-0x80000000)

MIDPOINT(real[, timeperiod=?])

MidPoint over period (Overlap Studies)

Inputs: real: (any ndarray) Parameters: timeperiod: 14 Outputs: real

MIDPRICE(high: Expr, low: Expr, timeperiod: float = 14.0) -> Expr

MIDPRICE(ndarray high, ndarray low, int timeperiod=-0x80000000)

MIDPRICE(high, low[, timeperiod=?])

Midpoint Price over period (Overlap Studies)

Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: real

MIN(close: Expr, timeperiod: float = 30.0) -> Expr

MIN(ndarray real, int timeperiod=-0x80000000)

MIN(real[, timeperiod=?])

Lowest value over a specified period (Math Operators)

Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real

MININDEX(close: Expr, timeperiod: float = 30.0) -> Expr

MININDEX(ndarray real, int timeperiod=-0x80000000)

MININDEX(real[, timeperiod=?])

Index of lowest value over a specified period (Math Operators)

Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: integer (values are -100, 0 or 100)

MINMAX(close: Expr, timeperiod: float = 30.0) -> Expr

MINMAX(ndarray real, int timeperiod=-0x80000000)

MINMAX(real[, timeperiod=?])

Lowest and highest values over a specified period (Math Operators)

Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: min max

MINMAXINDEX(close: Expr, timeperiod: float = 30.0) -> Expr

MINMAXINDEX(ndarray real, int timeperiod=-0x80000000)

MINMAXINDEX(real[, timeperiod=?])

Indexes of lowest and highest values over a specified period (Math Operators)

Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: minidx maxidx

MINUS_DI(high: Expr, low: Expr, close: Expr, timeperiod: float = 14.0) -> Expr

MINUS_DI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)

MINUS_DI(high, low, close[, timeperiod=?])

Minus Directional Indicator (Momentum Indicators)

Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real

MINUS_DM(high: Expr, low: Expr, timeperiod: float = 14.0) -> Expr

MINUS_DM(ndarray high, ndarray low, int timeperiod=-0x80000000)

MINUS_DM(high, low[, timeperiod=?])

Minus Directional Movement (Momentum Indicators)

Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: real

MOM(close: Expr, timeperiod: float = 10.0) -> Expr

MOM(ndarray real, int timeperiod=-0x80000000)

MOM(real[, timeperiod=?])

Momentum (Momentum Indicators)

Inputs: real: (any ndarray) Parameters: timeperiod: 10 Outputs: real

MULT(high: Expr, low: Expr) -> Expr

MULT(ndarray real0, ndarray real1)

MULT(real0, real1)

Vector Arithmetic Mult (Math Operators)

Inputs: real0: (any ndarray) real1: (any ndarray) Outputs: real

NATR(high: Expr, low: Expr, close: Expr, timeperiod: float = 14.0) -> Expr

NATR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)

NATR(high, low, close[, timeperiod=?])

Normalized Average True Range (Volatility Indicators)

Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real

OBV(close: Expr, volume: Expr) -> Expr

OBV(ndarray real, ndarray volume)

OBV(real, volume)

On Balance Volume (Volume Indicators)

Inputs: real: (any ndarray) prices: ['volume'] Outputs: real

PLUS_DI(high: Expr, low: Expr, close: Expr, timeperiod: float = 14.0) -> Expr

PLUS_DI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)

PLUS_DI(high, low, close[, timeperiod=?])

Plus Directional Indicator (Momentum Indicators)

Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real

PLUS_DM(high: Expr, low: Expr, timeperiod: float = 14.0) -> Expr

PLUS_DM(ndarray high, ndarray low, int timeperiod=-0x80000000)

PLUS_DM(high, low[, timeperiod=?])

Plus Directional Movement (Momentum Indicators)

Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: real

PPO(close: Expr, fastperiod: float = 12.0, slowperiod: float = 26.0, matype: float = 0.0) -> Expr

PPO(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int matype=0)

PPO(real[, fastperiod=?, slowperiod=?, matype=?])

Percentage Price Oscillator (Momentum Indicators)

Inputs: real: (any ndarray) Parameters: fastperiod: 12 slowperiod: 26 matype: 0 (Simple Moving Average) Outputs: real

ROC(close: Expr, timeperiod: float = 10.0) -> Expr

ROC(ndarray real, int timeperiod=-0x80000000)

ROC(real[, timeperiod=?])

Rate of change : ((real/prevPrice)-1)*100 (Momentum Indicators)

Inputs: real: (any ndarray) Parameters: timeperiod: 10 Outputs: real

ROCP(close: Expr, timeperiod: float = 10.0) -> Expr

ROCP(ndarray real, int timeperiod=-0x80000000)

ROCP(real[, timeperiod=?])

Rate of change Percentage: (real-prevPrice)/prevPrice (Momentum Indicators)

Inputs: real: (any ndarray) Parameters: timeperiod: 10 Outputs: real

ROCR(close: Expr, timeperiod: float = 10.0) -> Expr

ROCR(ndarray real, int timeperiod=-0x80000000)

ROCR(real[, timeperiod=?])

Rate of change ratio: (real/prevPrice) (Momentum Indicators)

Inputs: real: (any ndarray) Parameters: timeperiod: 10 Outputs: real

ROCR100(close: Expr, timeperiod: float = 10.0) -> Expr

ROCR100(ndarray real, int timeperiod=-0x80000000)

ROCR100(real[, timeperiod=?])

Rate of change ratio 100 scale: (real/prevPrice)*100 (Momentum Indicators)

Inputs: real: (any ndarray) Parameters: timeperiod: 10 Outputs: real

RSI(close: Expr, timeperiod: float = 14.0) -> Expr

RSI(ndarray real, int timeperiod=-0x80000000)

RSI(real[, timeperiod=?])

Relative Strength Index (Momentum Indicators)

Inputs: real: (any ndarray) Parameters: timeperiod: 14 Outputs: real

SAR(high: Expr, low: Expr, acceleration: float = 0.02, maximum: float = 0.2) -> Expr

SAR(ndarray high, ndarray low, double acceleration=0.02, double maximum=0.2)

SAR(high, low[, acceleration=?, maximum=?])

Parabolic SAR (Overlap Studies)

Inputs: prices: ['high', 'low'] Parameters: acceleration: 0.02 maximum: 0.2 Outputs: real

SAREXT(high: Expr, low: Expr, startvalue: float = 0.0, offsetonreverse: float = 0.0, accelerationinitlong: float = 0.02, accelerationlong: float = 0.02, accelerationmaxlong: float = 0.2, accelerationinitshort: float = 0.02, accelerationshort: float = 0.02, accelerationmaxshort: float = 0.2) -> Expr

SAREXT(ndarray high, ndarray low, double startvalue=-4e37, double offsetonreverse=-4e37, double accelerationinitlong=-4e37, double accelerationlong=-4e37, double accelerationmaxlong=-4e37, double accelerationinitshort=-4e37, double accelerationshort=-4e37, double accelerationmaxshort=-4e37)

SAREXT(high, low[, startvalue=?, offsetonreverse=?, accelerationinitlong=?, accelerationlong=?, accelerationmaxlong=?, accelerationinitshort=?, accelerationshort=?, accelerationmaxshort=?])

Parabolic SAR - Extended (Overlap Studies)

Inputs: prices: ['high', 'low'] Parameters: startvalue: 0.0 offsetonreverse: 0.0 accelerationinitlong: 0.02 accelerationlong: 0.02 accelerationmaxlong: 0.2 accelerationinitshort: 0.02 accelerationshort: 0.02 accelerationmaxshort: 0.2 Outputs: real

SIN(close: Expr) -> Expr

SIN(ndarray real)

SIN(real)

Vector Trigonometric Sin (Math Transform)

Inputs: real: (any ndarray) Outputs: real

SINH(close: Expr) -> Expr

SINH(ndarray real)

SINH(real)

Vector Trigonometric Sinh (Math Transform)

Inputs: real: (any ndarray) Outputs: real

SMA(close: Expr, timeperiod: float = 30.0) -> Expr

SMA(ndarray real, int timeperiod=-0x80000000)

SMA(real[, timeperiod=?])

Simple Moving Average (Overlap Studies)

Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real

SQRT(close: Expr) -> Expr

SQRT(ndarray real)

SQRT(real)

Vector Square Root (Math Transform)

Inputs: real: (any ndarray) Outputs: real

STDDEV(close: Expr, timeperiod: float = 5.0, nbdev: float = 1.0) -> Expr

STDDEV(ndarray real, int timeperiod=-0x80000000, double nbdev=-4e37)

STDDEV(real[, timeperiod=?, nbdev=?])

Standard Deviation (Statistic Functions)

Inputs: real: (any ndarray) Parameters: timeperiod: 5 nbdev: 1.0 Outputs: real

STOCH(high: Expr, low: Expr, close: Expr, fastk_period: float = 5.0, slowk_period: float = 3.0, slowk_matype: float = 0.0, slowd_period: float = 3.0, slowd_matype: float = 0.0) -> Expr

STOCH(ndarray high, ndarray low, ndarray close, int fastk_period=-0x80000000, int slowk_period=-0x80000000, int slowk_matype=0, int slowd_period=-0x80000000, int slowd_matype=0)

STOCH(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?])

Stochastic (Momentum Indicators)

Inputs: prices: ['high', 'low', 'close'] Parameters: fastk_period: 5 slowk_period: 3 slowk_matype: 0 slowd_period: 3 slowd_matype: 0 Outputs: slowk slowd

STOCHF(high: Expr, low: Expr, close: Expr, fastk_period: float = 5.0, fastd_period: float = 3.0, fastd_matype: float = 0.0) -> Expr

STOCHF(ndarray high, ndarray low, ndarray close, int fastk_period=-0x80000000, int fastd_period=-0x80000000, int fastd_matype=0)

STOCHF(high, low, close[, fastk_period=?, fastd_period=?, fastd_matype=?])

Stochastic Fast (Momentum Indicators)

Inputs: prices: ['high', 'low', 'close'] Parameters: fastk_period: 5 fastd_period: 3 fastd_matype: 0 Outputs: fastk fastd

STOCHRSI(close: Expr, timeperiod: float = 14.0, fastk_period: float = 5.0, fastd_period: float = 3.0, fastd_matype: float = 0.0) -> Expr

STOCHRSI(ndarray real, int timeperiod=-0x80000000, int fastk_period=-0x80000000, int fastd_period=-0x80000000, int fastd_matype=0)

STOCHRSI(real[, timeperiod=?, fastk_period=?, fastd_period=?, fastd_matype=?])

Stochastic Relative Strength Index (Momentum Indicators)

Inputs: real: (any ndarray) Parameters: timeperiod: 14 fastk_period: 5 fastd_period: 3 fastd_matype: 0 Outputs: fastk fastd

SUB(high: Expr, low: Expr) -> Expr

SUB(ndarray real0, ndarray real1)

SUB(real0, real1)

Vector Arithmetic Subtraction (Math Operators)

Inputs: real0: (any ndarray) real1: (any ndarray) Outputs: real

SUM(close: Expr, timeperiod: float = 30.0) -> Expr

SUM(ndarray real, int timeperiod=-0x80000000)

SUM(real[, timeperiod=?])

Summation (Math Operators)

Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real

T3(close: Expr, timeperiod: float = 5.0, vfactor: float = 0.7) -> Expr

T3(ndarray real, int timeperiod=-0x80000000, double vfactor=-4e37)

T3(real[, timeperiod=?, vfactor=?])

Triple Exponential Moving Average (T3) (Overlap Studies)

Inputs: real: (any ndarray) Parameters: timeperiod: 5 vfactor: 0.7 Outputs: real

TAN(close: Expr) -> Expr

TAN(ndarray real)

TAN(real)

Vector Trigonometric Tan (Math Transform)

Inputs: real: (any ndarray) Outputs: real

TANH(close: Expr) -> Expr

TANH(ndarray real)

TANH(real)

Vector Trigonometric Tanh (Math Transform)

Inputs: real: (any ndarray) Outputs: real

TEMA(close: Expr, timeperiod: float = 30.0) -> Expr

TEMA(ndarray real, int timeperiod=-0x80000000)

TEMA(real[, timeperiod=?])

Triple Exponential Moving Average (Overlap Studies)

Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real

TRANGE(high: Expr, low: Expr, close: Expr) -> Expr

TRANGE(ndarray high, ndarray low, ndarray close)

TRANGE(high, low, close)

True Range (Volatility Indicators)

Inputs: prices: ['high', 'low', 'close'] Outputs: real

TRIMA(close: Expr, timeperiod: float = 30.0) -> Expr

TRIMA(ndarray real, int timeperiod=-0x80000000)

TRIMA(real[, timeperiod=?])

Triangular Moving Average (Overlap Studies)

Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real

TRIX(close: Expr, timeperiod: float = 30.0) -> Expr

TRIX(ndarray real, int timeperiod=-0x80000000)

TRIX(real[, timeperiod=?])

1-day Rate-Of-Change (ROC) of a Triple Smooth EMA (Momentum Indicators)

Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real

TSF(close: Expr, timeperiod: float = 14.0) -> Expr

TSF(ndarray real, int timeperiod=-0x80000000)

TSF(real[, timeperiod=?])

Time Series Forecast (Statistic Functions)

Inputs: real: (any ndarray) Parameters: timeperiod: 14 Outputs: real

TYPPRICE(high: Expr, low: Expr, close: Expr) -> Expr

TYPPRICE(ndarray high, ndarray low, ndarray close)

TYPPRICE(high, low, close)

Typical Price (Price Transform)

Inputs: prices: ['high', 'low', 'close'] Outputs: real

ULTOSC(high: Expr, low: Expr, close: Expr, timeperiod1: float = 7.0, timeperiod2: float = 14.0, timeperiod3: float = 28.0) -> Expr

ULTOSC(ndarray high, ndarray low, ndarray close, int timeperiod1=-0x80000000, int timeperiod2=-0x80000000, int timeperiod3=-0x80000000)

ULTOSC(high, low, close[, timeperiod1=?, timeperiod2=?, timeperiod3=?])

Ultimate Oscillator (Momentum Indicators)

Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod1: 7 timeperiod2: 14 timeperiod3: 28 Outputs: real

VAR(close: Expr, timeperiod: float = 5.0, nbdev: float = 1.0) -> Expr

VAR(ndarray real, int timeperiod=-0x80000000, double nbdev=-4e37)

VAR(real[, timeperiod=?, nbdev=?])

Variance (Statistic Functions)

Inputs: real: (any ndarray) Parameters: timeperiod: 5 nbdev: 1.0 Outputs: real

WCLPRICE(high: Expr, low: Expr, close: Expr) -> Expr

WCLPRICE(ndarray high, ndarray low, ndarray close)

WCLPRICE(high, low, close)

Weighted Close Price (Price Transform)

Inputs: prices: ['high', 'low', 'close'] Outputs: real

WILLR(high: Expr, low: Expr, close: Expr, timeperiod: float = 14.0) -> Expr

WILLR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)

WILLR(high, low, close[, timeperiod=?])

Williams' %R (Momentum Indicators)

Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real

WMA(close: Expr, timeperiod: float = 30.0) -> Expr

WMA(ndarray real, int timeperiod=-0x80000000)

WMA(real[, timeperiod=?])

Weighted Moving Average (Overlap Studies)

Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real