扩展指标
This commit is contained in:
@@ -0,0 +1,656 @@
|
||||
"""
|
||||
Overlap Studies — Moving averages and bands that overlay directly on the price chart.
|
||||
|
||||
Functions
|
||||
---------
|
||||
SMA — Simple Moving Average
|
||||
EMA — Exponential Moving Average
|
||||
WMA — Weighted Moving Average
|
||||
DEMA — Double Exponential Moving Average
|
||||
TEMA — Triple Exponential Moving Average
|
||||
TRIMA — Triangular Moving Average
|
||||
KAMA — Kaufman Adaptive Moving Average
|
||||
T3 — Triple Exponential Moving Average (Tillson T3)
|
||||
BBANDS — Bollinger Bands
|
||||
MACD — Moving Average Convergence/Divergence
|
||||
MACDFIX — MACD with fixed 12/26 periods
|
||||
MACDEXT — MACD with controllable MA types
|
||||
SAR — Parabolic SAR
|
||||
SAREXT — Parabolic SAR Extended
|
||||
MA — Generic Moving Average (dispatches on matype)
|
||||
MAVP — Moving Average with Variable Period
|
||||
MAMA — MESA Adaptive Moving Average
|
||||
MIDPOINT — MidPoint over period
|
||||
MIDPRICE — MidPrice over period (High/Low)
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import numpy as np
|
||||
from numpy.typing import ArrayLike
|
||||
|
||||
from ferro_ta._ferro_ta import (
|
||||
bbands as _bbands,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
dema as _dema,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
ema as _ema,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
kama as _kama,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
ma as _ma,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
macd as _macd,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
macdext as _macdext,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
macdfix as _macdfix,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
mama as _mama,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
mavp as _mavp,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
midpoint as _midpoint,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
midprice as _midprice,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
sar as _sar,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
sarext as _sarext,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
sma as _sma,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
t3 as _t3,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
tema as _tema,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
trima as _trima,
|
||||
)
|
||||
from ferro_ta._ferro_ta import (
|
||||
wma as _wma,
|
||||
)
|
||||
from ferro_ta._utils import _to_f64
|
||||
from ferro_ta.core.exceptions import _normalize_rust_error
|
||||
|
||||
|
||||
def SMA(close: ArrayLike, timeperiod: int = 30) -> np.ndarray:
|
||||
"""Simple Moving Average.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
close : array-like
|
||||
Sequence of closing prices.
|
||||
timeperiod : int, optional
|
||||
Number of periods (default 30).
|
||||
|
||||
Returns
|
||||
-------
|
||||
numpy.ndarray
|
||||
Array of SMA values; leading ``timeperiod - 1`` entries are ``NaN``.
|
||||
"""
|
||||
try:
|
||||
return _sma(_to_f64(close), timeperiod)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def EMA(close: ArrayLike, timeperiod: int = 30) -> np.ndarray:
|
||||
"""Exponential Moving Average.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
close : array-like
|
||||
Sequence of closing prices.
|
||||
timeperiod : int, optional
|
||||
Number of periods (default 30).
|
||||
|
||||
Returns
|
||||
-------
|
||||
numpy.ndarray
|
||||
Array of EMA values; leading ``timeperiod - 1`` entries are ``NaN``.
|
||||
"""
|
||||
try:
|
||||
return _ema(_to_f64(close), timeperiod)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def WMA(close: ArrayLike, timeperiod: int = 30) -> np.ndarray:
|
||||
"""Weighted Moving Average.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
close : array-like
|
||||
Sequence of closing prices.
|
||||
timeperiod : int, optional
|
||||
Number of periods (default 30).
|
||||
|
||||
Returns
|
||||
-------
|
||||
numpy.ndarray
|
||||
Array of WMA values; leading ``timeperiod - 1`` entries are ``NaN``.
|
||||
"""
|
||||
try:
|
||||
return _wma(_to_f64(close), timeperiod)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def DEMA(close: ArrayLike, timeperiod: int = 30) -> np.ndarray:
|
||||
"""Double Exponential Moving Average.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
close : array-like
|
||||
Sequence of closing prices.
|
||||
timeperiod : int, optional
|
||||
Number of periods (default 30).
|
||||
|
||||
Returns
|
||||
-------
|
||||
numpy.ndarray
|
||||
Array of DEMA values; leading ``2 * (timeperiod - 1)`` entries are ``NaN``.
|
||||
"""
|
||||
try:
|
||||
return _dema(_to_f64(close), timeperiod)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def TEMA(close: ArrayLike, timeperiod: int = 30) -> np.ndarray:
|
||||
"""Triple Exponential Moving Average.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
close : array-like
|
||||
Sequence of closing prices.
|
||||
timeperiod : int, optional
|
||||
Number of periods (default 30).
|
||||
|
||||
Returns
|
||||
-------
|
||||
numpy.ndarray
|
||||
Array of TEMA values; leading ``3 * (timeperiod - 1)`` entries are ``NaN``.
|
||||
"""
|
||||
try:
|
||||
return _tema(_to_f64(close), timeperiod)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def TRIMA(close: ArrayLike, timeperiod: int = 30) -> np.ndarray:
|
||||
"""Triangular Moving Average.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
close : array-like
|
||||
Sequence of closing prices.
|
||||
timeperiod : int, optional
|
||||
Number of periods (default 30).
|
||||
|
||||
Returns
|
||||
-------
|
||||
numpy.ndarray
|
||||
Array of TRIMA values; leading ``timeperiod - 1`` entries are ``NaN``.
|
||||
"""
|
||||
try:
|
||||
return _trima(_to_f64(close), timeperiod)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def KAMA(close: ArrayLike, timeperiod: int = 30) -> np.ndarray:
|
||||
"""Kaufman Adaptive Moving Average.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
close : array-like
|
||||
Sequence of closing prices.
|
||||
timeperiod : int, optional
|
||||
Efficiency Ratio lookback period (default 30).
|
||||
|
||||
Returns
|
||||
-------
|
||||
numpy.ndarray
|
||||
Array of KAMA values; leading ``timeperiod - 1`` entries are ``NaN``.
|
||||
"""
|
||||
try:
|
||||
return _kama(_to_f64(close), timeperiod)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def T3(close: ArrayLike, timeperiod: int = 5, vfactor: float = 0.7) -> np.ndarray:
|
||||
"""Triple Exponential Moving Average (Tillson T3).
|
||||
|
||||
Parameters
|
||||
----------
|
||||
close : array-like
|
||||
Sequence of closing prices.
|
||||
timeperiod : int, optional
|
||||
Number of periods (default 5).
|
||||
vfactor : float, optional
|
||||
Volume factor (default 0.7).
|
||||
|
||||
Returns
|
||||
-------
|
||||
numpy.ndarray
|
||||
Array of T3 values.
|
||||
"""
|
||||
try:
|
||||
return _t3(_to_f64(close), timeperiod, vfactor)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def BBANDS(
|
||||
close: ArrayLike,
|
||||
timeperiod: int = 5,
|
||||
nbdevup: float = 2.0,
|
||||
nbdevdn: float = 2.0,
|
||||
) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
|
||||
"""Bollinger Bands.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
close : array-like
|
||||
Sequence of closing prices.
|
||||
timeperiod : int, optional
|
||||
Moving average window (default 5).
|
||||
nbdevup : float, optional
|
||||
Number of standard deviations above the middle band (default 2.0).
|
||||
nbdevdn : float, optional
|
||||
Number of standard deviations below the middle band (default 2.0).
|
||||
|
||||
Returns
|
||||
-------
|
||||
tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]
|
||||
``(upperband, middleband, lowerband)`` — three arrays of equal length.
|
||||
Leading ``timeperiod - 1`` entries are ``NaN``.
|
||||
"""
|
||||
try:
|
||||
return _bbands(_to_f64(close), timeperiod, nbdevup, nbdevdn)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def MACD(
|
||||
close: ArrayLike,
|
||||
fastperiod: int = 12,
|
||||
slowperiod: int = 26,
|
||||
signalperiod: int = 9,
|
||||
) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
|
||||
"""Moving Average Convergence/Divergence.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
close : array-like
|
||||
Sequence of closing prices.
|
||||
fastperiod : int, optional
|
||||
Fast EMA period (default 12).
|
||||
slowperiod : int, optional
|
||||
Slow EMA period (default 26).
|
||||
signalperiod : int, optional
|
||||
Signal EMA period (default 9).
|
||||
|
||||
Returns
|
||||
-------
|
||||
tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]
|
||||
``(macd, signal, histogram)`` — three arrays of equal length.
|
||||
Leading values that cannot be computed are ``NaN``.
|
||||
"""
|
||||
try:
|
||||
return _macd(_to_f64(close), fastperiod, slowperiod, signalperiod)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def MACDFIX(
|
||||
close: ArrayLike,
|
||||
signalperiod: int = 9,
|
||||
) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
|
||||
"""Moving Average Convergence/Divergence Fix 12/26.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
close : array-like
|
||||
Sequence of closing prices.
|
||||
signalperiod : int, optional
|
||||
Signal EMA period (default 9).
|
||||
|
||||
Returns
|
||||
-------
|
||||
tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]
|
||||
``(macd, signal, histogram)`` — three arrays of equal length.
|
||||
"""
|
||||
try:
|
||||
return _macdfix(_to_f64(close), signalperiod)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def SAR(
|
||||
high: ArrayLike,
|
||||
low: ArrayLike,
|
||||
acceleration: float = 0.02,
|
||||
maximum: float = 0.2,
|
||||
) -> np.ndarray:
|
||||
"""Parabolic SAR.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
high : array-like
|
||||
Sequence of high prices.
|
||||
low : array-like
|
||||
Sequence of low prices.
|
||||
acceleration : float, optional
|
||||
Acceleration factor step (default 0.02).
|
||||
maximum : float, optional
|
||||
Maximum acceleration factor (default 0.2).
|
||||
|
||||
Returns
|
||||
-------
|
||||
numpy.ndarray
|
||||
Array of SAR values; first entry is ``NaN``.
|
||||
"""
|
||||
try:
|
||||
return _sar(_to_f64(high), _to_f64(low), acceleration, maximum)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def MIDPOINT(close: ArrayLike, timeperiod: int = 14) -> np.ndarray:
|
||||
"""MidPoint over period — (max + min) / 2 of close.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
close : array-like
|
||||
Sequence of closing prices.
|
||||
timeperiod : int, optional
|
||||
Number of periods (default 14).
|
||||
|
||||
Returns
|
||||
-------
|
||||
numpy.ndarray
|
||||
Array of MIDPOINT values; leading ``timeperiod - 1`` entries are ``NaN``.
|
||||
"""
|
||||
try:
|
||||
return _midpoint(_to_f64(close), timeperiod)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def MIDPRICE(high: ArrayLike, low: ArrayLike, timeperiod: int = 14) -> np.ndarray:
|
||||
"""MidPrice over period — (highest high + lowest low) / 2.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
high : array-like
|
||||
Sequence of high prices.
|
||||
low : array-like
|
||||
Sequence of low prices.
|
||||
timeperiod : int, optional
|
||||
Number of periods (default 14).
|
||||
|
||||
Returns
|
||||
-------
|
||||
numpy.ndarray
|
||||
Array of MIDPRICE values; leading ``timeperiod - 1`` entries are ``NaN``.
|
||||
"""
|
||||
try:
|
||||
return _midprice(_to_f64(high), _to_f64(low), timeperiod)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def MA(close: ArrayLike, timeperiod: int = 30, matype: int = 0) -> np.ndarray:
|
||||
"""Generic Moving Average.
|
||||
|
||||
Dispatches to the appropriate MA implementation based on *matype*.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
close : array-like
|
||||
Sequence of closing prices.
|
||||
timeperiod : int, optional
|
||||
Number of periods (default 30).
|
||||
matype : int, optional
|
||||
Moving average type (default 0):
|
||||
|
||||
* 0 = SMA (Simple)
|
||||
* 1 = EMA (Exponential)
|
||||
* 2 = WMA (Weighted)
|
||||
* 3 = DEMA (Double EMA)
|
||||
* 4 = TEMA (Triple EMA)
|
||||
* 5 = TRIMA (Triangular)
|
||||
* 6 = KAMA (Kaufman Adaptive)
|
||||
* 7 = T3 (Tillson)
|
||||
|
||||
Returns
|
||||
-------
|
||||
numpy.ndarray
|
||||
Array of MA values.
|
||||
"""
|
||||
try:
|
||||
return _ma(_to_f64(close), timeperiod, matype)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def MAVP(
|
||||
close: ArrayLike,
|
||||
periods: ArrayLike,
|
||||
minperiod: int = 2,
|
||||
maxperiod: int = 30,
|
||||
) -> np.ndarray:
|
||||
"""Moving Average with Variable Period.
|
||||
|
||||
Computes a simple moving average at each bar using the period given by the
|
||||
corresponding element of *periods*. Periods are clamped to
|
||||
``[minperiod, maxperiod]``.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
close : array-like
|
||||
Sequence of closing prices.
|
||||
periods : array-like
|
||||
Sequence of period values (one per bar, same length as *close*).
|
||||
minperiod : int, optional
|
||||
Minimum allowed period (default 2).
|
||||
maxperiod : int, optional
|
||||
Maximum allowed period (default 30).
|
||||
|
||||
Returns
|
||||
-------
|
||||
numpy.ndarray
|
||||
Array of variable-period MA values.
|
||||
"""
|
||||
try:
|
||||
return _mavp(_to_f64(close), _to_f64(periods), minperiod, maxperiod)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def MAMA(
|
||||
close: ArrayLike,
|
||||
fastlimit: float = 0.5,
|
||||
slowlimit: float = 0.05,
|
||||
) -> tuple[np.ndarray, np.ndarray]:
|
||||
"""MESA Adaptive Moving Average.
|
||||
|
||||
Returns the MAMA and FAMA (Following Adaptive MA) lines. The adaptive
|
||||
alpha is derived from the rate of phase change of the Hilbert Transform.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
close : array-like
|
||||
Sequence of closing prices.
|
||||
fastlimit : float, optional
|
||||
Upper bound on the adaptive smoothing factor (default 0.5).
|
||||
slowlimit : float, optional
|
||||
Lower bound on the adaptive smoothing factor (default 0.05).
|
||||
|
||||
Returns
|
||||
-------
|
||||
tuple[numpy.ndarray, numpy.ndarray]
|
||||
``(mama, fama)`` — two arrays; first 32 entries are ``NaN``.
|
||||
"""
|
||||
try:
|
||||
return _mama(_to_f64(close), fastlimit, slowlimit)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def SAREXT(
|
||||
high: ArrayLike,
|
||||
low: ArrayLike,
|
||||
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,
|
||||
) -> np.ndarray:
|
||||
"""Parabolic SAR Extended.
|
||||
|
||||
An extended version of the Parabolic SAR that allows independent
|
||||
acceleration parameters for long and short positions, plus an optional
|
||||
fixed start value and a gap-on-reverse offset.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
high : array-like
|
||||
Sequence of high prices.
|
||||
low : array-like
|
||||
Sequence of low prices.
|
||||
startvalue : float, optional
|
||||
Fixed initial SAR value (0 = auto-detect, default 0.0).
|
||||
offsetonreverse : float, optional
|
||||
Multiplier applied to the SAR on trend reversal (default 0.0).
|
||||
accelerationinitlong : float, optional
|
||||
Initial acceleration factor for long positions (default 0.02).
|
||||
accelerationlong : float, optional
|
||||
Acceleration step for long positions (default 0.02).
|
||||
accelerationmaxlong : float, optional
|
||||
Maximum acceleration for long positions (default 0.2).
|
||||
accelerationinitshort : float, optional
|
||||
Initial acceleration factor for short positions (default 0.02).
|
||||
accelerationshort : float, optional
|
||||
Acceleration step for short positions (default 0.02).
|
||||
accelerationmaxshort : float, optional
|
||||
Maximum acceleration for short positions (default 0.2).
|
||||
|
||||
Returns
|
||||
-------
|
||||
numpy.ndarray
|
||||
Array of SAREXT values; first entry is ``NaN``.
|
||||
"""
|
||||
try:
|
||||
return _sarext(
|
||||
_to_f64(high),
|
||||
_to_f64(low),
|
||||
startvalue,
|
||||
offsetonreverse,
|
||||
accelerationinitlong,
|
||||
accelerationlong,
|
||||
accelerationmaxlong,
|
||||
accelerationinitshort,
|
||||
accelerationshort,
|
||||
accelerationmaxshort,
|
||||
)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
def MACDEXT(
|
||||
close: ArrayLike,
|
||||
fastperiod: int = 12,
|
||||
fastmatype: int = 1,
|
||||
slowperiod: int = 26,
|
||||
slowmatype: int = 1,
|
||||
signalperiod: int = 9,
|
||||
signalmatype: int = 1,
|
||||
) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
|
||||
"""MACD with Controllable MA Types.
|
||||
|
||||
Like :func:`MACD` but allows specifying the moving average type for each
|
||||
of the fast, slow, and signal lines independently.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
close : array-like
|
||||
Sequence of closing prices.
|
||||
fastperiod : int, optional
|
||||
Fast MA period (default 12).
|
||||
fastmatype : int, optional
|
||||
MA type for the fast line (default 1 = EMA).
|
||||
slowperiod : int, optional
|
||||
Slow MA period (default 26).
|
||||
slowmatype : int, optional
|
||||
MA type for the slow line (default 1 = EMA).
|
||||
signalperiod : int, optional
|
||||
Signal MA period (default 9).
|
||||
signalmatype : int, optional
|
||||
MA type for the signal line (default 1 = EMA).
|
||||
|
||||
MA type codes: 0=SMA, 1=EMA, 2=WMA.
|
||||
|
||||
Returns
|
||||
-------
|
||||
tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]
|
||||
``(macd, signal, histogram)`` — three arrays of equal length.
|
||||
"""
|
||||
try:
|
||||
return _macdext(
|
||||
_to_f64(close),
|
||||
fastperiod,
|
||||
fastmatype,
|
||||
slowperiod,
|
||||
slowmatype,
|
||||
signalperiod,
|
||||
signalmatype,
|
||||
)
|
||||
except ValueError as e:
|
||||
_normalize_rust_error(e)
|
||||
|
||||
|
||||
__all__ = [
|
||||
"SMA",
|
||||
"EMA",
|
||||
"WMA",
|
||||
"DEMA",
|
||||
"TEMA",
|
||||
"TRIMA",
|
||||
"KAMA",
|
||||
"T3",
|
||||
"BBANDS",
|
||||
"MACD",
|
||||
"MACDFIX",
|
||||
"MACDEXT",
|
||||
"SAR",
|
||||
"SAREXT",
|
||||
"MA",
|
||||
"MAVP",
|
||||
"MAMA",
|
||||
"MIDPOINT",
|
||||
"MIDPRICE",
|
||||
]
|
||||
Reference in New Issue
Block a user