Skip to content
The Chat Archive
claude-opus-4-20250514· Anthropic LMArena Human Preference 140K

Essa á classe do ta4j que calcula rsi: public class RSIIndicator extends…

  1. User

    Essa á classe do ta4j que calcula rsi:

    public class RSIIndicator extends CachedIndicator {

    private final MMAIndicator averageGainIndicator;
    private final MMAIndicator averageLossIndicator;
    
    /**
     * Constructor.
     *
     * @param indicator the {@link Indicator}
     * @param barCount  the time frame
     */
    public RSIIndicator(Indicator<Num> indicator, int barCount) {
        super(indicator);
        this.averageGainIndicator = new MMAIndicator(new GainIndicator(indicator), barCount);
        this.averageLossIndicator = new MMAIndicator(new LossIndicator(indicator), barCount);
    }
    
    @Override
    protected Num calculate(int index) {
        // compute relative strength
        Num averageGain = averageGainIndicator.getValue(index);
        Num averageLoss = averageLossIndicator.getValue(index);
        final var numFactory = getBarSeries().numFactory();
        if (averageLoss.isZero()) {
            return averageGain.isZero() ? numFactory.zero() : numFactory.hundred();
        }
        Num relativeStrength = averageGain.dividedBy(averageLoss);
        // compute relative strength index
        return numFactory.hundred().minus(numFactory.hundred().dividedBy(numFactory.one().plus(relativeStrength)));
    }
    
    @Override
    public int getCountOfUnstableBars() {
        return 0;
    }
    

    }

  2. Assistant

    Perfeito! Agora encontramos a raiz do problema. A classe RSIIndicator do ta4j está usando MMAIndicator (Modified Moving Average), que é a implementação correta do método de Wilder. Mas vamos verificar se a implementação está realmente correta.

    O Problema Potencial: MMAIndicator

    A MMAIndicator do ta4j deveria implementar a suavização de Wilder, mas vamos verificar se está fazendo isso corretamente. A fórmula de Wilder para o RSI é:

    Primeira Média de Ganhos = Soma dos primeiros N ganhos / N
    Médias Subsequentes = ((Média Anterior * (N-1)) + Ganho Atual) / N
    

    Você pode verificar a implementação da MMAIndicator no ta4j? Ela deve ser algo assim:

    public class MMAIndicator extends CachedIndicator<Num> {
        private final Indicator<Num> indicator;
        private final int barCount;
    
        public MMAIndicator(Indicator<Num> indicator, int barCount) {
            super(indicator);
            this.indicator = indicator;
            this.barCount = barCount;
        }
    
        @Override
        protected Num calculate(int index) {
            if (index == 0) {
                return indicator.getValue(0);
            }
            if (index < barCount) {
                // Calcula SMA para os primeiros 'barCount' valores
                Num sum = numFactory.zero();
                for (int i = 0; i <= index; i++) {
                    sum = sum.plus(indicator.getValue(i));
                }
                return sum.dividedBy(numFactory.numOf(index + 1));
            }
            // Aplica a fórmula MMA/Wilder
            Num prev = getValue(index - 1);
            Num current = indicator.getValue(index);
            return prev.multipliedBy(numFactory.numOf(barCount - 1))
                       .plus(current)
                       .dividedBy(numFactory.numOf(barCount));
        }
    }
    

    Possíveis Causas da Diferença de 10 Pontos

    1. Inicialização Diferente: A Binance pode estar usando uma inicialização diferente para o primeiro valor da média. Algumas implementações usam SMA para os primeiros N valores, outras começam com o primeiro valor e aplicam EMA desde o início.

    2. Período de Aquecimento: Com RSI(5), você precisa de pelo menos 5 períodos para calcular as médias de ganhos/perdas, mas para ter valores estáveis, você precisa de muito mais. A Binance tem milhares de candles históricos, enquanto você pode estar começando com apenas algumas dezenas.

    Solução: Debugar Passo a Passo

    Vamos criar um código de debug para entender exatamente o que está acontecendo:

    public void debugRSI(Map<CurrencyPairDTO, BarSeries> candlesAsBars) {
        candlesAsBars.forEach((pair, series) -> {
            if (series.getBarCount() < 20) { // Precisamos de mais dados para debug
                logger.warn("Poucos dados para debug do RSI em {}", pair);
                return;
            }
    
            ClosePriceIndicator closePrice = new ClosePriceIndicator(series);
            GainIndicator gains = new GainIndicator(closePrice);
            LossIndicator losses = new LossIndicator(closePrice);
            MMAIndicator avgGain = new MMAIndicator(gains, 5);
            MMAIndicator avgLoss = new MMAIndicator(losses, 5);
            RSIIndicator rsi = new RSIIndicator(closePrice, 5);
    
            // Vamos imprimir os últimos 10 valores para análise
            logger.info("=== Debug RSI para {} ===", pair);
            for (int i = Math.max(10, series.getBeginIndex() + 10); i <= series.getEndIndex(); i++) {
                Num close = closePrice.getValue(i);
                Num gain = gains.getValue(i);
                Num loss = losses.getValue(i);
                Num avgG = avgGain.getValue(i);
                Num avgL = avgLoss.getValue(i);
                Num rsiValue = rsi.getValue(i);
                
                logger.info("Index {}: Close={}, Gain={}, Loss={}, AvgGain={}, AvgLoss={}, RSI={}",
                    i,
                    close.decimalValue().setScale(2, RoundingMode.HALF_UP),
                    gain.decimalValue().setScale(4, RoundingMode.HALF_UP),
                    loss.decimalValue().setScale(4, RoundingMode.HALF_UP),
                    avgG.decimalValue().setScale(4, RoundingMode.HALF_UP),
                    avgL.decimalValue().setScale(4, RoundingMode.HALF_UP),
                    rsiValue.decimalValue().setScale(2, RoundingMode.HALF_UP)
                );
            }
        });
    }
    

    Alternativa: Implementar RSI Manualmente

    Se a diferença persistir, você pode implementar o RSI exatamente como a Binance faz:

    public class BinanceCompatibleRSI {
        
        public static BigDecimal calculateRSI(List<BigDecimal> prices, int period) {
            if (prices.size() < period + 1) {
                throw new IllegalArgumentException("Dados insuficientes");
            }
            
            List<BigDecimal> gains = new ArrayList<>();
            List<BigDecimal> losses = new ArrayList<>();
            
            // Calcula ganhos e perdas
            for (int i = 1; i < prices.size(); i++) {
                BigDecimal diff = prices.get(i).subtract(prices.get(i - 1));
                if (diff.compareTo(BigDecimal.ZERO) > 0) {
                    gains.add(diff);
                    losses.add(BigDecimal.ZERO);
                } else {
                    gains.add(BigDecimal.ZERO);
                    losses.add(diff.abs());
                }
            }
            
            // Calcula primeira média (SMA)
            BigDecimal avgGain = gains.subList(0, period).stream()
                .reduce(BigDecimal.ZERO, BigDecimal::add)
                .divide(BigDecimal.valueOf(period), 10, RoundingMode.HALF_UP);
                
            BigDecimal avgLoss = losses.subList(0, period).stream()
                .reduce(BigDecimal.ZERO, BigDecimal::add)
                .divide(BigDecimal.valueOf(period), 10, RoundingMode.HALF_UP);
            
            // Aplica suavização de Wilder para os valores restantes
            for (int i = period; i < gains.size(); i++) {
                avgGain = avgGain.multiply(BigDecimal.valueOf(period - 1))
                    .add(gains.get(i))
                    .divide(BigDecimal.valueOf(period), 10, RoundingMode.HALF_UP);
                    
                avgLoss = avgLoss.multiply(BigDecimal.valueOf(period - 1))
                    .add(losses.get(i))
                    .divide(BigDecimal.valueOf(period), 10, RoundingMode.HALF_UP);
            }
            
            // Calcula RS e RSI
            if (avgLoss.compareTo(BigDecimal.ZERO) == 0) {
                return BigDecimal.valueOf(100);
            }
            
            BigDecimal rs = avgGain.divide(avgLoss, 10, RoundingMode.HALF_UP);
            BigDecimal rsi = BigDecimal.valueOf(100).subtract(
                BigDecimal.valueOf(100).divide(
                    BigDecimal.ONE.add(rs), 10, RoundingMode.HALF_UP
                )
            );
            
            return rsi;
        }
    }
    

    Recomendação Final

    1. Primeiro, execute o código de debug para ver os valores intermediários
    2. Compare com os valores da Binance para o mesmo período exato
    3. Verifique se você está comparando candles fechados (não o candle atual em formação)
    4. Certifique-se de ter pelo menos 50-100 candles de histórico para o RSI convergir

    A diferença de 10 pontos é significativa demais para ser apenas arredondamento. Provavelmente é uma combinação de:

    • Dados ligeiramente diferentes
    • Período de aquecimento insuficiente
    • Comparação com o candle errado (atual vs fechado)

    Execute o debug e me mostre os resultados - assim podemos identificar exatamente onde está a divergência!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.

Identical first prompt