ADX, CCI and Stochastic Conditions for Crypto Long Trades
Article Strategy library · Author: freqtrade
Summary
This five-minute long-only strategy combines trend strength, oversold readings, and a fast stochastic crossover to define entries. It requires either a high short-period ADX or a qualifying slower ADX, a CCI below its oversold level, and both fast and slow stochastic readings to have been low on the prior candle. It then looks for the fast stochastic lines to cross upward, with volume and minimum-price filters. The exit rule checks for weaker slow ADX, elevated fast stochastic readings, a downward stochastic crossover, and price above a short EMA.
The source also specifies staged return targets, a stop loss, and limit entries and exits, though these settings can be overridden by configuration. It calculates a rolling volume average and explicitly warns that using a whole-dataframe average in backtests would introduce lookahead; the rolling calculation avoids that particular issue. No asset, backtest interval, or performance results are reported in the document. The many simultaneous thresholds may reduce signal frequency and require testing across markets and conditions.
Key ideas
- Entries combine ADX trend-strength conditions with oversold CCI and fast and slow stochastic readings.
- A fast stochastic upward crossover is required after the prior readings were oversold.
- The exit signal uses weaker slow ADX, elevated stochastic values, a downward crossover, and price above a short EMA.
- The strategy defines return targets and a stop loss, while configuration may override them.
- The document warns that a full-dataframe volume average would introduce lookahead in backtests.
Tags
Full text
# Strategy004
# Strategy004
Strategy 004
author@: Gerald Lonlas
github@: https://github.com/freqtrade/freqtrade-strategies
How to use it?
> python3 ./freqtrade/main.py -s Strategy004
## Source (GPL-3.0)
```python
# --- Do not remove these libs ---
from freqtrade.strategy import IStrategy
from typing import Dict, List
from functools import reduce
from pandas import DataFrame
# --------------------------------
import talib.abstract as ta
class Strategy004(IStrategy):
"""
Strategy 004
author@: Gerald Lonlas
github@: https://github.com/freqtrade/freqtrade-strategies
How to use it?
> python3 ./freqtrade/main.py -s Strategy004
"""
INTERFACE_VERSION: int = 3
# Minimal ROI designed for the strategy.
# This attribute will be overridden if the config file contains "minimal_roi"
minimal_roi = {
"60": 0.01,
"30": 0.03,
"20": 0.04,
"0": 0.05
}
# Optimal stoploss designed for the strategy
# This attribute will be overridden if the config file contains "stoploss"
stoploss = -0.10
# Optimal timeframe for the strategy
timeframe = '5m'
# trailing stoploss
trailing_stop = False
trailing_stop_positive = 0.01
trailing_stop_positive_offset = 0.02
# run "populate_indicators" only for new candle
process_only_new_candles = True
# Experimental settings (configuration will overide these if set)
use_exit_signal = True
exit_profit_only = True
ignore_roi_if_entry_signal = False
# Optional order type mapping
order_types = {
'entry': 'limit',
'exit': 'limit',
'stoploss': 'market',
'stoploss_on_exchange': False
}
def informative_pairs(self):
"""
Define additional, informative pair/interval combinations to be cached from the exchange.
These pair/interval combinations are non-tradeable, unless they are part
of the whitelist as well.
For more information, please consult the documentation
:return: List of tuples in the format (pair, interval)
Sample: return [("ETH/USDT", "5m"),
("BTC/USDT", "15m"),
]
"""
return []
def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Adds several different TA indicators to the given DataFrame
Performance Note: For the best performance be frugal on the number of indicators
you are using. Let uncomment only the indicator you are using in your strategies
or your hyperopt configuration, otherwise you will waste your memory and CPU usage.
"""
# ADX
dataframe['adx'] = ta.ADX(dataframe)
dataframe['slowadx'] = ta.ADX(dataframe, 35)
# Commodity Channel Index: values Oversold:<-100, Overbought:>100
dataframe['cci'] = ta.CCI(dataframe)
# Stoch
stoch = ta.STOCHF(dataframe, 5)
dataframe['fastd'] = stoch['fastd']
dataframe['fastk'] = stoch['fastk']
dataframe['fastk-previous'] = dataframe.fastk.shift(1)
dataframe['fastd-previous'] = dataframe.fastd.shift(1)
# Slow Stoch
slowstoch = ta.STOCHF(dataframe, 50)
dataframe['slowfastd'] = slowstoch['fastd']
dataframe['slowfastk'] = slowstoch['fastk']
dataframe['slowfastk-previous'] = dataframe.slowfastk.shift(1)
dataframe['slowfastd-previous'] = dataframe.slowfastd.shift(1)
# EMA - Exponential Moving Average
dataframe['ema5'] = ta.EMA(dataframe, timeperiod=5)
# get the rolling volume mean for the last hour (12x5)
# Note: dataframe['volume'].mean() uses the whole dataframe in
# backtesting hence will have lookahead, but would be fine for dry/live use
dataframe['mean-volume'] = dataframe['volume'].rolling(12).mean()
return dataframe
def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Based on TA indicators, populates the buy signal for the given dataframe
:param dataframe: DataFrame
:return: DataFrame with buy column
"""
dataframe.loc[
(
(
(dataframe['adx'] > 50) |
(dataframe['slowadx'] > 26)
) &
(dataframe['cci'] < -100) &
(
(dataframe['fastk-previous'] < 20) &
(dataframe['fastd-previous'] < 20)
) &
(
(dataframe['slowfastk-previous'] < 30) &
(dataframe['slowfastd-previous'] < 30)
) &
(dataframe['fastk-previous'] < dataframe['fastd-previous']) &
(dataframe['fastk'] > dataframe['fastd']) &
(dataframe['mean-volume'] > 0.75) &
(dataframe['close'] > 0.00000100)
),
'enter_long'] = 1
return dataframe
def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Based on TA indicators, populates the sell signal for the given dataframe
:param dataframe: DataFrame
:return: DataFrame with buy column
"""
dataframe.loc[
(
(dataframe['slowadx'] < 25) &
((dataframe['fastk'] > 70) | (dataframe['fastd'] > 70)) &
(dataframe['fastk-previous'] < dataframe['fastd-previous']) &
(dataframe['close'] > dataframe['ema5'])
),
'exit_long'] = 1
return dataframe
```Shown in full with attribution under the source's licence. Licence: GPL-3.0
This summary was written by Stratmill's research agent from the original; it is not a copy of the source.