Triple-EMA-RSI-ATR: A Comprehensive Algorithm for Trading in Cryptocurrency, Stock Markets, and CFD

by

Introduction

The world of trading, whether in the cryptocurrency realm, stock markets, or Contract for Differences (CFD), requires intricate strategies to maximize gains and mitigate potential losses. One such strategy is the Triple-EMA-RSI-ATR algorithm. Designed with precision and based on the collaborative strength of three renowned technical indicators, this algorithm seeks to harness the power of the market’s data. Before delving into its intricacies, let’s first journey into the history and significance of each of its components. For those interested in delving deeper or seeking professional guidance, the Botix Inquiry Form remains a critical resource.

The Power Trio: EMA, RSI, and ATR

  1. Exponential Moving Average (EMA): EMA is a type of moving average that places a greater weight and significance on the most recent data points. Unlike the simple moving average, EMA responds more quickly to recent price changes. The EMA is integral in identifying trends. Learn more about the EMA from Wikipedia.
  2. Relative Strength Index (RSI): Developed by J. Welles Wilder, RSI is a momentum oscillator that measures the speed and change of price movements. RSI oscillates between zero and 100. Traditionally, and according to Wilder, RSI is considered overbought when above 70 and oversold when below 30. It can be used to identify the general trend. Dive deeper into the RSI here.
  3. Average True Range (ATR): Created by J. Welles Wilder, the ATR measures market volatility. It is typically used with commodities, but can be applied to stocks, indices, and cryptocurrencies. A higher ATR indicates higher volatility. Learn more about ATR here.

Why Use These Three Indicators Together?

The rationale behind integrating these three indicators in one algorithm is to harness their combined strengths. The EMA provides insights into trends with more weight on recent data, making it agile in reflecting market changes. The RSI, meanwhile, offers a glimpse into the asset’s momentum and potential reversals. Finally, the ATR measures the asset’s volatility, vital for determining the strength behind a price movement.

The Triple-EMA-RSI-ATR algorithm, by synergizing these indicators, aims to offer traders a precise tool for making decisions, capturing both trend and momentum, all while accounting for market volatility.

The Algorithm’s Versatility

A pivotal strength of the Triple-EMA-RSI-ATR algorithm is its ability to adapt. While its default setting is the 1-minute interval, catering to short-term traders, it can be adjusted for longer time frames, appealing to swing or position traders.

Moreover, the algorithm has the unique capability to open both long and short positions simultaneously. This hedging strategy provides an added layer of security in volatile markets. Moreover, by continuously monitoring the market on a 1-minute candle interval, it ensures traders don’t miss crucial exit points, whether to lock in profits or prevent excessive losses.

In events of radical market fluctuations, the algorithm’s predefined maximum profit and loss percentages are crucial. By capping potential losses and profits, it provides a safety net against extreme market unpredictability.

Breaking Down the Code

Written in JavaScript, the code for the Triple-EMA-RSI-ATR algorithm is both intricate and powerful. Let’s dissect it.

// Required libraries for technical analysis
const technicalIndicators = require('technicalindicators');

class Triple_EMA_RSI_ATR {
    
    // Defining maximum profit percentage for sharp market rises
    getProfitPercent(){
        return 0.03;
    }

    // Defining maximum loss percentage for sharp market drops
    getLossPercent(){
        return 0.04;
    }

    // Main calculation method to evaluate market data and decide on trade actions
    async calculate(ohlcv) {
        // Extracting required data from the OHLCV dataset
        let closePrices = ohlcv.map(x => x[4]);
        let highPrices = ohlcv.map(x => x[2]);
        let lowPrices = ohlcv.map(x => x[3]);

        const high1 = highPrices[highPrices.length - 1];
        const low1 = lowPrices[lowPrices.length - 1];
        const lastPrice = closePrices[closePrices.length - 1];

        // Calculating Exponential Moving Averages for different periods
        let ema200 = new technicalIndicators.EMA({ values: closePrices, period: 200 }).getResult();
        let ema50 = new technicalIndicators.EMA({ values: closePrices, period: 50 }).getResult();
        let ema25 = new technicalIndicators.EMA({ values: closePrices, period: 9 }).getResult();

        // Recent values for EMAs
        const ema50last = ema50[ema50.length - 1];
        const ema2001 = ema200[ema200.length - 1];

        // Calculating Relative Strength Index (RSI) and Average True Range (ATR)
        let rsi = new technicalIndicators.RSI({ values: closePrices, period: 28 }).getResult();
        let atr = new technicalIndicators.ATR({ high: highPrices, low: lowPrices, close: closePrices, period: 28 }).getResult();

        // Calculating RSI values and slopes
        const rsislice = rsi.slice(-40);
        const rsimax = Math.max(...rsislice);
        const rsimin = Math.min(...rsislice);
        const rsi1 = rsi[rsi.length - 1];

        const atr1 = atr[atr.length - 1];
        const atr60 = atr[atr.length - 60];
        const atrSlope = atr1 / atr60;

        // Calculating EMA slopes and conditions for determining long and short positions
        const slicedEma50 = ema50.slice(-ema50.length, -10);
        const ema50min = Math.min(...slicedEma50);
        const ema50max = Math.max(...slicedEma50);

        const ema50minIndex = slicedEma50.indexOf(ema50min) + (ema50.length - slicedEma50.length);
        const ema50maxIndex = slicedEma50.indexOf(ema50max) + (ema50.length - slicedEma50.length);

        // Conditions for opening long and short positions based on analyzed data
        const goodForLong  = ema50last / low1 > 1.003 && rsi1 < 42 && rsi1 > 32 && atrSlope > 1 && rsi1 == rsimin && ema50max / ema50last < 1.003 && ema50minIndex > ema50maxIndex;
        const goodForShort = high1 / ema50last > 1.003 && rsi1 > 58 && rsi1 < 68 && atrSlope < 1 && rsi1 == rsimax && ema50last / ema50min < 1.003 && ema50minIndex < ema50maxIndex;

        let rsiFallDown = false;
        let rsiGoesUp = false;

        // Determine RSI trend over the last 10 periods
        for (let i = 0; i < 10 && i < rsi.length; i++) {
            let rsiValue = rsi[rsi.length - 1 - i];
            if (rsiValue < 40) {
                rsiFallDown = true;
                break;
            } else if (rsiValue > 60) {
                rsiGoesUp = true;
                break;
            }
        }
    
        const emaFastSlope = ema25[ema25.length - 1] / ema25[ema25.length - 3];
        this.lastCals = {
            emaFastSlope,
            rsiFallDown,
            rsiGoesUp,
            lastPrice,
            lastIndex: closePrices.length - 1,
            goodForLong,
            goodForShort,
        }
    }

    // Check if conditions are suitable for a long position
    canLong() {
        const lc = this.lastCals;
        return lc.goodForLong
    }

    // Check if conditions are suitable for a short position
    canShort() {
        const lc = this.lastCals;
        return lc.goodForShort
    }

    // Determine when to close a long position
    canCloseLong(position) {
        const lc = this.lastCals;

        return (position.posSide === 'long' && 
                (this.lastCals.lastPrice >= position.profitBond || 
                 this.lastCals.lastPrice <= position.stopLossBond || 
                 (lc.rsiFallDown && lc.emaFastSlope < 0.997)));
    }

    // Determine when to close a short position
    canCloseShort(position) {
        const lc = this.lastCals;

        return (position.posSide === 'short' && 
                (this.lastCals.lastPrice <= position.profitBond || 
                 this.lastCals.lastPrice >= position.stopLossBond || 
                 (lc.rsiGoesUp && lc.emaFastSlope > 1.003)));
    }
}

Each function and parameter in this code is meticulously crafted to factor in the complex interplay of the three indicators. From defining the percentages for profits and losses to calculating conditions for opening and closing positions, the code ensures traders have a robust tool at their disposal.

Using the Algorithm

To effectively harness the Triple-EMA-RSI-ATR algorithm, traders need to:

  1. Understand the Indicators: Before deploying the algorithm, traders should deeply understand the EMA, RSI, and ATR indicators. Each plays a critical role in the algorithm’s decisions.
  2. Configure and Test: Given the variable nature of markets, it’s wise to test the algorithm in a sandbox or simulation environment before going live.
  3. Continuous Monitoring: Even with the algorithm at work, traders should keep a close eye on the markets. Set alerts, be ready to intervene, and always stay informed.

Conclusion

The Triple-EMA-RSI-ATR algorithm stands as a testament to the power of collaborative indicators. In the chaotic world of trading, be it cryptocurrencies, stocks, or CFDs, having an algorithm that’s both precise and adaptable is invaluable.

Are you interested in implementing the Triple-EMA-RSI-ATR algorithm for your trading endeavors? Do you have inquiries on how to customize it further for your specific needs? Reach out to us through the Botix Inquiry Form. Together, let’s harness the power of smart trading.