def cci(high, low, close, length=None, c=None, offset=None, **kwargs):
"""Indicator: Commodity Channel Index (CCI)"""
# Validate Arguments
high = verify_series(high)
low = verify_series(low)
close = verify_series(close)
length = int(length) if length and length > 0 else 14
c = float(c) if c and c > 0 else 0.015
offset = get_offset(offset)
# Calculate Result
typical_price = hlc3(high=high, low=low, close=close)
mean_typical_price = sma(typical_price, length=length)
mad_typical_price = mad(typical_price, length=length)
cci = typical_price - mean_typical_price
cci /= c * mad_typical_price
# Offset
if offset != 0:
cci = cci.shift(offset)
# Handle fills
if "fillna" in kwargs:
cci.fillna(kwargs["fillna"], inplace=True)
if "fill_method" in kwargs:
cci.fillna(method=kwargs["fill_method"], inplace=True)
# Name and Categorize it
cci.name = f"CCI_{length}_{c}"
cci.category = "momentum"
return cci
def aberration(high,
low,
close,
length=None,
atr_length=None,
offset=None,
**kwargs):
"""Indicator: Aberration (ABER)"""
# Validate arguments
high = verify_series(high)
low = verify_series(low)
close = verify_series(close)
length = int(length) if length and length > 0 else 5
atr_length = int(atr_length) if atr_length and atr_length > 0 else 15
offset = get_offset(offset)
# Calculate Result
atr_ = atr(high=high, low=low, close=close, length=atr_length)
jg = hlc3(high=high, low=low, close=close)
zg = sma(jg, length)
sg = zg + atr_
xg = zg - atr_
# Offset
if offset != 0:
zg = zg.shift(offset)
sg = sg.shift(offset)
xg = xg.shift(offset)
atr_ = atr_.shift(offset)
# Handle fills
if "fillna" in kwargs:
zg.fillna(kwargs["fillna"], inplace=True)
sg.fillna(kwargs["fillna"], inplace=True)
xg.fillna(kwargs["fillna"], inplace=True)
atr_.fillna(kwargs["fillna"], inplace=True)
if "fill_method" in kwargs:
zg.fillna(method=kwargs["fill_method"], inplace=True)
sg.fillna(method=kwargs["fill_method"], inplace=True)
xg.fillna(method=kwargs["fill_method"], inplace=True)
atr_.fillna(method=kwargs["fill_method"], inplace=True)
# Name and Categorize it
_props = f"_{length}_{atr_length}"
zg.name = f"ABER_ZG{_props}"
sg.name = f"ABER_SG{_props}"
xg.name = f"ABER_XG{_props}"
atr_.name = f"ABER_ATR{_props}"
zg.category = sg.category = "volatility"
xg.category = atr_.category = zg.category
# Prepare DataFrame to return
data = {zg.name: zg, sg.name: sg, xg.name: xg, atr_.name: atr_}
aberdf = DataFrame(data)
aberdf.name = f"ABER{_props}"
aberdf.category = zg.category
return aberdf
def kvo(high,
low,
close,
volume,
fast=None,
slow=None,
signal=None,
mamode=None,
drift=None,
offset=None,
**kwargs):
"""Indicator: Klinger Volume Oscillator (KVO)"""
# Validate arguments
fast = int(fast) if fast and fast > 0 else 34
slow = int(slow) if slow and slow > 0 else 55
signal = int(signal) if signal and signal > 0 else 13
mamode = mamode.lower() if mamode and isinstance(mamode, str) else "ema"
_length = max(fast, slow, signal)
high = verify_series(high, _length)
low = verify_series(low, _length)
close = verify_series(close, _length)
volume = verify_series(volume, _length)
drift = get_drift(drift)
offset = get_offset(offset)
if high is None or low is None or close is None or volume is None: return
# Calculate Result
signed_volume = volume * signed_series(hlc3(high, low, close), 1)
sv = signed_volume.loc[signed_volume.first_valid_index():, ]
kvo = ma(mamode, sv, length=fast) - ma(mamode, sv, length=slow)
kvo_signal = ma(mamode, kvo.loc[kvo.first_valid_index():, ], length=signal)
# Offset
if offset != 0:
kvo = kvo.shift(offset)
kvo_signal = kvo_signal.shift(offset)
# Handle fills
if "fillna" in kwargs:
kvo.fillna(kwargs["fillna"], inplace=True)
kvo_signal.fillna(kwargs["fillna"], inplace=True)
if "fill_method" in kwargs:
kvo.fillna(method=kwargs["fill_method"], inplace=True)
kvo_signal.fillna(method=kwargs["fill_method"], inplace=True)
# Name and Categorize it
_props = f"_{fast}_{slow}_{signal}"
kvo.name = f"KVO{_props}"
kvo_signal.name = f"KVOs{_props}"
kvo.category = kvo_signal.category = "volume"
# Prepare DataFrame to return
data = {kvo.name: kvo, kvo_signal.name: kvo_signal}
df = DataFrame(data)
df.name = f"KVO{_props}"
df.category = kvo.category
return df
def mfi(high,
low,
close,
volume,
length=None,
talib=None,
drift=None,
offset=None,
**kwargs):
"""Indicator: Money Flow Index (MFI)"""
# Validate arguments
length = int(length) if length and length > 0 else 14
high = verify_series(high, length)
low = verify_series(low, length)
close = verify_series(close, length)
volume = verify_series(volume, length)
drift = get_drift(drift)
offset = get_offset(offset)
mode_tal = bool(talib) if isinstance(talib, bool) else True
if high is None or low is None or close is None or volume is None: return
# Calculate Result
if Imports["talib"] and mode_tal:
from talib import MFI
mfi = MFI(high, low, close, volume, length)
else:
typical_price = hlc3(high=high, low=low, close=close)
raw_money_flow = typical_price * volume
tdf = DataFrame({"diff": 0, "rmf": raw_money_flow, "+mf": 0, "-mf": 0})
tdf.loc[(typical_price.diff(drift) > 0), "diff"] = 1
tdf.loc[tdf["diff"] == 1, "+mf"] = raw_money_flow
tdf.loc[(typical_price.diff(drift) < 0), "diff"] = -1
tdf.loc[tdf["diff"] == -1, "-mf"] = raw_money_flow
psum = tdf["+mf"].rolling(length).sum()
nsum = tdf["-mf"].rolling(length).sum()
tdf["mr"] = psum / nsum
mfi = 100 * psum / (psum + nsum)
tdf["mfi"] = mfi
# Offset
if offset != 0:
mfi = mfi.shift(offset)
# Handle fills
if "fillna" in kwargs:
mfi.fillna(kwargs["fillna"], inplace=True)
if "fill_method" in kwargs:
mfi.fillna(method=kwargs["fill_method"], inplace=True)
# Name and Categorize it
mfi.name = f"MFI_{length}"
mfi.category = "volume"
return mfi
def kvo(high, low, close, volume, fast=None, slow=None, length_sig=None, mamode=None, drift=None, offset=None, **kwargs):
"""Indicator: Klinger Volume Oscillator (KVO)"""
# Validate arguments
fast = int(fast) if fast and fast > 0 else 34
slow = int(slow) if slow and slow > 0 else 55
length_sig = int(length_sig) if length_sig and length_sig > 0 else 13
mamode = mamode.lower() if mamode and isinstance(mamode, str) else "ema"
_length = max(fast, slow, length_sig)
high = verify_series(high, _length)
low = verify_series(low, _length)
close = verify_series(close, _length)
volume = verify_series(volume, _length)
drift = get_drift(drift)
offset = get_offset(offset)
if high is None or low is None or close is None or volume is None: return
# Calculate Result
mom = hlc3(high, low, close).diff(drift)
trend = npWhere(mom > 0, 1, 0) + npWhere(mom < 0, -1, 0)
dm = non_zero_range(high, low)
m = high.size
cm = [0] * m
for i in range(1, m):
cm[i] = (cm[i - 1] + dm[i]) if trend[i] == trend[i - 1] else (dm[i - 1] + dm[i])
vf = 100 * volume * trend * abs(2 * dm / cm - 1)
kvo = ma(mamode, vf, length=fast) - ma(mamode, vf, length=slow)
kvo_signal = ma(mamode, kvo, length=length_sig)
# Offset
if offset != 0:
kvo = kvo.shift(offset)
kvo_signal = kvo_signal.shift(offset)
# Handle fills
if "fillna" in kwargs:
kvo.fillna(kwargs["fillna"], inplace=True)
kvo_signal.fillna(kwargs["fillna"], inplace=True)
if "fill_method" in kwargs:
kvo.fillna(method=kwargs["fill_method"], inplace=True)
kvo_signal.fillna(method=kwargs["fill_method"], inplace=True)
# Name and Categorize it
kvo.name = f"KVO_{fast}_{slow}"
kvo_signal.name = f"KVOSig_{length_sig}"
kvo.category = kvo_signal.category = "volume"
# Prepare DataFrame to return
data = {kvo.name: kvo, kvo_signal.name: kvo_signal}
kvoandsig = DataFrame(data)
kvoandsig.name = f"KVO_{fast}_{slow}_{length_sig}"
kvoandsig.category = kvo.category
return kvoandsig
def mfi(high,
low,
close,
volume,
length=None,
drift=None,
offset=None,
**kwargs):
"""Indicator: Money Flow Index (MFI)"""
# Validate arguments
high = verify_series(high)
low = verify_series(low)
close = verify_series(close)
volume = verify_series(volume)
length = int(length) if length and length > 0 else 14
drift = get_drift(drift)
offset = get_offset(offset)
# Calculate Result
typical_price = hlc3(high=high, low=low, close=close)
raw_money_flow = typical_price * volume
tdf = DataFrame({"diff": 0, "rmf": raw_money_flow, "+mf": 0, "-mf": 0})
tdf.loc[(typical_price.diff(drift) > 0), "diff"] = 1
tdf.loc[tdf["diff"] == 1, "+mf"] = raw_money_flow
tdf.loc[(typical_price.diff(drift) < 0), "diff"] = -1
tdf.loc[tdf["diff"] == -1, "-mf"] = raw_money_flow
psum = tdf["+mf"].rolling(length).sum()
nsum = tdf["-mf"].rolling(length).sum()
tdf["mr"] = psum / nsum
mfi = 100 * psum / (psum + nsum)
tdf["mfi"] = mfi
# Offset
if offset != 0:
mfi = mfi.shift(offset)
# Handle fills
if "fillna" in kwargs:
mfi.fillna(kwargs["fillna"], inplace=True)
if "fill_method" in kwargs:
mfi.fillna(method=kwargs["fill_method"], inplace=True)
# Name and Categorize it
mfi.name = f"MFI_{length}"
mfi.category = "volume"
return mfi
def cci(high,
low,
close,
length=None,
c=None,
talib=None,
offset=None,
**kwargs):
"""Indicator: Commodity Channel Index (CCI)"""
# Validate Arguments
length = int(length) if length and length > 0 else 14
c = float(c) if c and c > 0 else 0.015
high = verify_series(high, length)
low = verify_series(low, length)
close = verify_series(close, length)
offset = get_offset(offset)
mode_tal = bool(talib) if isinstance(talib, bool) else True
if high is None or low is None or close is None: return
# Calculate Result
if Imports["talib"] and mode_tal:
from talib import CCI
cci = CCI(high, low, close, length)
else:
typical_price = hlc3(high=high, low=low, close=close)
mean_typical_price = sma(typical_price, length=length)
mad_typical_price = mad(typical_price, length=length)
cci = typical_price - mean_typical_price
cci /= c * mad_typical_price
# Offset
if offset != 0:
cci = cci.shift(offset)
# Handle fills
if "fillna" in kwargs:
cci.fillna(kwargs["fillna"], inplace=True)
if "fill_method" in kwargs:
cci.fillna(method=kwargs["fill_method"], inplace=True)
# Name and Categorize it
cci.name = f"CCI_{length}_{c}"
cci.category = "momentum"
return cci
