Python talib.MFI屬性代碼示例

# 需要導入模塊: import talib [as 別名]
# 或者: from talib import MFI [as 別名]
def add_MFI(self, timeperiod=14,
            type='line', color='secondary', **kwargs):
    """Money Flow Index."""

    if not (self.has_high and self.has_low and
            self.has_close and self.has_volume):
        raise Exception()

    utils.kwargs_check(kwargs, VALID_TA_KWARGS)
    if 'kind' in kwargs:
        type = kwargs['kind']

    name = 'MFI({})'.format(str(timeperiod))
    self.sec[name] = dict(type=type, color=color)
    self.ind[name] = talib.MFI(self.df[self.hi].values,
                               self.df[self.lo].values,
                               self.df[self.cl].values,
                               self.df[self.vo].values,
                               timeperiod) 

# 需要導入模塊: import talib [as 別名]
# 或者: from talib import MFI [as 別名]
def mfi(candles: np.ndarray, period=14, sequential=False) -> Union[float, np.ndarray]:
    """
    MFI - Money Flow Index

    :param candles: np.ndarray
    :param period: int - default=14
    :param sequential: bool - default=False

    :return: float | np.ndarray
    """
    if not sequential and len(candles) > 240:
        candles = candles[-240:]

    res = talib.MFI(candles[:, 3], candles[:, 4], candles[:, 2], candles[:, 5], timeperiod=period)

    if sequential:
        return res
    else:
        return None if np.isnan(res[-1]) else res[-1] 

# 需要導入模塊: import talib [as 別名]
# 或者: from talib import MFI [as 別名]
def get_indicator(df, indicator):
        ret_df = df
        if 'MACD' in indicator:
            macd, macdsignal, macdhist = ta.MACD(df.close.values, fastperiod=12, slowperiod=26, signalperiod=9)
            ret_df = KlineData._merge_dataframe(pd.DataFrame([macd, macdsignal, macdhist]).T.rename(columns={0: "macddif", 1: "macddem", 2: "macdhist"}), ret_df)
            ret_df = KlineData._merge_dataframe(line_intersections(ret_df, columns=['macddif', 'macddem']), ret_df)
        if 'MFI' in indicator:
            real = ta.MFI(df.high.values, df.low.values, df.close.values, df.volume.values, timeperiod=14)
            ret_df = KlineData._merge_dataframe(pd.DataFrame([real]).T.rename(columns={0: "mfi"}), ret_df)
        if 'ATR' in indicator:
            real = ta.NATR(df.high.values, df.low.values, df.close.values, timeperiod=14)
            ret_df = KlineData._merge_dataframe(pd.DataFrame([real]).T.rename(columns={0: "atr"}), ret_df)
        if 'ROCR' in indicator:
            real = ta.ROCR(df.close.values, timeperiod=10)
            ret_df = KlineData._merge_dataframe(pd.DataFrame([real]).T.rename(columns={0: "rocr"}), ret_df)
        ret_df['date'] = pd.to_datetime(ret_df['date'], format='%Y-%m-%d')
        return ret_df 

# 需要導入模塊: import talib [as 別名]
# 或者: from talib import MFI [as 別名]
def calculate_mfi(self, period_name, highs, lows, closing_prices, volumes):
        mfi = talib.MFI(highs, lows, closing_prices, volumes)

        self.current_indicators[period_name]['mfi'] = mfi[-1] 

# 需要導入模塊: import talib [as 別名]
# 或者: from talib import MFI [as 別名]
def mfi(self, sym, frequency, *args, **kwargs):
        if not self.kbars_ready(sym, frequency):
            return []

        highs = self.high(sym, frequency)
        lows = self.low(sym, frequency)
        closes = self.close(sym, frequency)
        volumes = self.volume(sym, frequency)

        v = ta.MFI(highs, lows, closes, volumes, *args, **kwargs)

        return v 

# 需要導入模塊: import talib [as 別名]
# 或者: from talib import MFI [as 別名]
def test_mfi():
    '''test TA.MFI'''

    mfi = TA.MFI(ohlc, 9)
    talib_mfi = talib.MFI(ohlc['high'], ohlc['low'], ohlc['close'], ohlc['volume'], 9)

    assert int(talib_mfi[-1]) == int(mfi.values[-1]) 

# 需要導入模塊: import talib [as 別名]
# 或者: from talib import MFI [as 別名]
def MFI(frame, n=14, high_col='high', low_col='low', close_col='close', vol_col='Volume'):
    """money flow inedx"""
    return _frame_to_series(frame, [high_col, low_col, close_col, vol_col], talib.MFI, n) 

# 需要導入模塊: import talib [as 別名]
# 或者: from talib import MFI [as 別名]
def test_mfi(self):
        result = pandas_ta.mfi(self.high, self.low, self.close, self.volume_)
        self.assertIsInstance(result, Series)
        self.assertEqual(result.name, 'MFI_14')

        try:
            expected = tal.MFI(self.high, self.low, self.close, self.volume_)
            pdt.assert_series_equal(result, expected, check_names=False)
        except AssertionError as ae:
            try:
                corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION)
                self.assertGreater(corr, CORRELATION_THRESHOLD)
            except Exception as ex:
                error_analysis(result, CORRELATION, ex) 

# 需要導入模塊: import talib [as 別名]
# 或者: from talib import MFI [as 別名]
def MFI(data, **kwargs):
    _check_talib_presence()
    popen, phigh, plow, pclose, pvolume = _extract_ohlc(data)
    return talib.MFI(popen, phigh, plow, pclose, pvolume, **kwargs)