Calcul RSI PRT

Bonjour,

Je sais que le sujet a été évoqué de nombreuses fois. Cependant malgré 2 jours de travail il m'est impossible de reproduire le rsi identique à celui sur prt.

Le calcul est pourtant simple et se trouve un peu partout mais impossible de retrouvé la même valeur que prt.

Quelqu'un pourrait me dire comment est calculé le rsi sur prt.
Perso j'ai testé en 100T sur un RSI5 et j'ai un decalage de 30. prt est à 60 alors que moi je suis à 90.
Je fais bien le calcul suivant : rsi = 100-(100/Calc_RSI_NB);

Calc_RSI_NB = Calc_RSI_NB+1;
Calc_RSI_NB = Moyenne_Hausse_RSI/Moyenne_Basse_RSI;

Je me demande si prt n'utilise pas une moyenne exponentielle pour calculer la moyenne des Hausses/Baisses

Je sais pas si quelqu'un saura m'en dire plus.

En tout cas merci par avance

Salut. Il me semble que la moyenne à utiliser c'est la moyenne de Wilder ? (du nom du créateur du rsi)

Du coup c'est bien la somme des "hausse/période total" soir dans mon test 5, c'est bien ce que j'ai essayé.

J'ai tenté via excel en prenant les valeurs direct sur le graph de prt et impossible de retrouver les mêmes valeurs

Merci pour ton aide en tout cas

En fait je te dis des bêtises : je ne sais plus quel type de moyenne utilise prt. C'est peut-être une MM simple.

As-tu bien suivi cette procédure : https://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:relative_strength_index_rsi ?

Je pense que c'est la bonne.

Je ne connaissais pas la notion de lissage.
J'ai donc tenté d'ajuster sans résultat.

Mais une chose un peu plus folle m'interpelle, j'ai repris le tableau excel sur le lien et je n'arrive pas non plus au même résultat avec la formule donnée.. Mon "Avg Gain" n'est pas identique à la présentation.

Ce rsi me rend fou!!!

:p j'ai le code Java mais ça risque de ne pas trop t'aider ?

alors la si justement je l'utilise en javascript ce serait top!!!

Juste pour partager voici mon code :

Code : #

function Calc_RSI(close, heure, Periode_RSI, UT){
	compteur_RSI = compteur_RSI+1;
	Tab_RSI[compteur_RSI]=close;
	var longueur_Tab_RSI=Tab_RSI.length;
	var Debut_RSI = longueur_Tab_RSI-Periode_RSI;
	
	var Nb_Enregistrement = document.getElementById("Nb_Enregistrement_Tab_RSI"); 
	Nb_Enregistrement.value = longueur_Tab_RSI; 
	
	if (longueur_Tab_RSI > Periode_RSI) { // Calcul RSI en cours
		var Activation_RSI = document.getElementById("Activation_RSI"); 
		Activation_RSI.value = "Active";
		
		var Compteur_RSI_deux = 0;
		var ecart_Hausse_RSI = 0;
		var ecart_Baisse_RSI = 0;
		var Hausse_RSI = 0;
		var Baisse_RSI = 0;
		var Close_der_barre_prec = 0;
		var Compteur_RSI_SURACHAT = 0;
		var Calc_RSI_NB = 0;
		var RSI = 0;
		var Compteur_RSI_Hausse = 0;
		var Compteur_RSI_Baisse = 0;
		
		for (var i=Debut_RSI; i<longueur_Tab_RSI; i++) { // Boucle recuperation valeurs dans un tableau
			Compteur_RSI_deux = Compteur_RSI_deux+1;
			Tab_RSI_PERIODE[Compteur_RSI_deux] = Tab_RSI[i];
			var Close_der_barre = Tab_RSI[i];
			if (Compteur_RSI_deux == 1) {
				Close_der_barre_prec = Close_der_barre;
			} else {	
				if (Close_der_barre > Close_der_barre_prec) {
					ecart_Hausse_RSI = Number(Close_der_barre)-Number(Close_der_barre_prec);
					Hausse_RSI = Number(Hausse_RSI)+Number(ecart_Hausse_RSI);
					Close_der_barre_prec = Close_der_barre;
					Compteur_RSI_Hausse = Compteur_RSI_Hausse+1;
				}
				// dans le cas d'une baisse
				if (Close_der_barre < Close_der_barre_prec) {
					ecart_Baisse_RSI = Number(Close_der_barre_prec)-Number(Close_der_barre);
					Baisse_RSI = Number(Baisse_RSI)+Number(ecart_Baisse_RSI);
					Close_der_barre_prec = Close_der_barre;
					Compteur_RSI_Baisse = Compteur_RSI_Baisse+1;
				}
			}
		}

		//------------
		if (Compteur_RSI_Hausse == 0) {
			Moyenne_Hausse_RSI = 0;
		} else {
			Moyenne_Hausse_RSI = Hausse_RSI/Periode_RSI;
		}
		
		if (Compteur_RSI_Baisse == 0) {
			Moyenne_Basse_RSI = 0;
		} else {
			Moyenne_Basse_RSI = Baisse_RSI/Periode_RSI;
		}
		
		Calc_RSI_NB = (Number(Moyenne_Hausse_RSI)/Number(Moyenne_Basse_RSI));
		Calc_RSI_NB = Calc_RSI_NB+1;
		RSI = 100-(100/Calc_RSI_NB);

		Tab_RSI_FIN[longueur_Tab_RSI] = Math.ceil(RSI*100)/100;	
		
		var Calcul_RSI = document.getElementById("Calcul_RSI"); 
		Calcul_RSI.value = Tab_RSI_FIN[longueur_Tab_RSI];
		var Tableau_RSI = document.getElementById("Tableau_RSI"); 
		Tableau_RSI.value = Tab_RSI_FIN; 
		
		//------
		
		
		Tab_Heure_RSI[longueur_Tab_RSI] = heure;
		var Heure_RSI = document.getElementById("Heure_RSI"); 
		Heure_RSI.value = Tab_Heure_RSI;
		
	} else {
		// Profondeur pas sufisante
		var Activation_RSI = document.getElementById("Activation_RSI"); 
		Activation_RSI.value = "En cours de chargement";
	}
	var Valeur_Tab_RSI = document.getElementById("Valeur_Tab_RSI"); 
	Valeur_Tab_RSI.value = Tab_RSI_PERIODE;	
}

Ah ok, mais toi c'est du javascript, pas du Java. Je te mets le code Java au cas où , mais c'est complètement différent. Longtemps que je n'y ai pas touché, mais il me semble me souvenir que ça donnait les mêmes résultats que PRT.

Code : #

public class RSIFunction implements IFunction {
    private static final Logger logger = LogManager.getLogger(RSIFunction.class);

    private int nbPeriods;
    private BigDecimal ATR;
    private List<BigDecimal> listSeedDown;
    private List<BigDecimal> listSeedUp;
    private BigDecimal averageUps;
    private BigDecimal averageDowns;
    private OHLC previousOHLC;
    private boolean isSeedInitialized;
    private boolean skipfirst = true;

    public RSIFunction(int nbPeriods) {
        this.nbPeriods = nbPeriods;
        listSeedDown = new ArrayList<>();
        listSeedUp = new ArrayList<>();
    }

    public boolean hasEnoughQuotes() {
        if (listSeedDown.size()  + listSeedUp.size() < nbPeriods) {
            return false;
        } else {
            return true;
        }
    }

    public BigDecimal computeNewValue(OHLC newOHLC) {
        BigDecimal delta = null;
		
        delta = newOHLC.getClose().subtract(previousOHLC.getClose());
        previousOHLC = newOHLC;

        if (!isSeedInitialized) {

            if (delta.compareTo(BigDecimal.ZERO) < 0) {
                listSeedDown.add(delta.abs());
            } else {
                listSeedUp.add(delta);
            }

            if (hasEnoughQuotes()) {
            // on a suffisamment de quotes pour initialiser le RSI
                isSeedInitialized = true;

                averageDowns = listSeedDown.stream().reduce(BigDecimal.ZERO, BigDecimal::add).divide(new BigDecimal(nbPeriods), 20, RoundingMode.HALF_UP);
                averageUps = listSeedUp.stream().reduce(BigDecimal.ZERO, BigDecimal::add).divide(new BigDecimal(nbPeriods), 20, RoundingMode.HALF_UP);

                BigDecimal RS;
                if (averageDowns.compareTo(BigDecimal.ZERO) != 0) {
                    RS = averageUps.divide(averageDowns, 20, RoundingMode.HALF_UP);
                } else {
                    RS = new BigDecimal(100);
                }

                BigDecimal RSI = new BigDecimal(100).subtract(
                        new BigDecimal(100).divide(BigDecimal.ONE.add(RS), 20, RoundingMode.HALF_UP));

                return RSI;
            }
        } else {
            BigDecimal upValue;
            BigDecimal downValue;

            if (delta.compareTo(BigDecimal.ZERO) < 0) {
                downValue = delta.abs();
                upValue = BigDecimal.ZERO;
            } else {
                upValue = delta;
                downValue = BigDecimal.ZERO;
            }

            averageDowns = averageDowns.multiply(
                    new BigDecimal(nbPeriods - 1)
                ).setScale(20, RoundingMode.HALF_UP)
                    .add(downValue)
                    .divide(new BigDecimal(nbPeriods), 20, RoundingMode.HALF_UP);
            averageUps = averageUps.multiply(new BigDecimal(nbPeriods - 1)).setScale(20, RoundingMode.HALF_UP).add(upValue).divide(new BigDecimal(nbPeriods), 20, RoundingMode.HALF_UP);

            BigDecimal RS;
            if (averageDowns.compareTo(BigDecimal.ZERO) != 0) {
                RS = averageUps.divide(averageDowns, 20, RoundingMode.HALF_UP);
            } else {
                RS = new BigDecimal(100);
            }

            BigDecimal RSI = new BigDecimal(100).subtract(
                    new BigDecimal(100).divide(BigDecimal.ONE.add(RS), 20, RoundingMode.HALF_UP));

            return RSI;
        }
        return null;
    }
}

Sinon si ça t'aide pas, je regarderai ton code tout à l'heure.

je vais éplucher ta fonction cette nuit merci beaucoup

Ben si tu as deux minutes pour vérifier la mienne ce serait top

merci

J'ai l'impression qu'il manque la prise en compte de la moyenne précédente, pour la calcul des moyennes. J'illustre mes propos sur la base d'un RSI 14 périodes:

Code : #

Moyenne_Hausse_RSI = Hausse_RSI / Periode_RSI;

Ca c'est bon pour le premier passage (le cas if (!isSeedInitialized) { de mon code). Ainsi dés que tu as tes 14 premières valeurs (si c'est du RSI 14 par exemple), tu peux calculer ta première moyenne.

Ensuite il faut faire quelque chose comme :

Code : #

Moyenne_Hausse_RSI = Moyenne_Hausse_RSI_Precedente * 13 + Number(ecart_Hausse_RSI) / Periode_RSI;

Je sais pas si je suis clair ? En somme 1) initialiser la première valeur de chaque moyenne, à partir des 14 premières close ensuite 2) réutiliser à chaque fois la moyenne précédente * 13 + nouvelle valeur / 14.

En somme c'est ce que je fais dans mon code Java, mais te prends pas la tête sur ce code c'est pas super compréhensible si on connaît pas Java (notamment Java 8)

Merci pour ton aide ca m'a fait comprendre mon erreur. Je reprenais non pas la somme n-1 + la valeur en cours mais la somme n-1 + la moyenne en cours....

Je vais modifier ma fonction et tester

Ok bon hésite pas si t'as besoin alors. content d'être utile aussi.

Sur mon prt le code du rsi est dispo dans un indicateur qui s'intitule "Exemple : rsi" et qui est éditable. Peut-être que vous l'avez aussi ?

Bien vu Jim. J'avais zappé ça

Merci pour votre aide j'ai enfin réussi à retrouver le bon resultat.
Je partage ma fonction même si elle n'est pas super propre

Code : #

function Calc_RSI_V2(close, heure, Periode_RSI, UT){
	compteur_RSI_V2 = compteur_RSI_V2+1;
	compteur_RSI_Moins_V2 = compteur_RSI_V2-1;
	Periode_RSI_Moins = Periode_RSI-1;
	Tab_Valeur[compteur_RSI_V2] = close; // On envoi les niveau de cloture dans un tableau

	// Calcul de l'ecart UP et DOWN actuel
	if (compteur_RSI_V2 > 1) { // Si on a minimum deux valeur dans le tableau
		Ecart_Valeur = Tab_Valeur[compteur_RSI_V2]-Tab_Valeur[compteur_RSI_Moins_V2];
		if (Ecart_Valeur >= 0) {
			UP[compteur_RSI_V2] = Ecart_Valeur;
			DOWN[compteur_RSI_V2] = 0;
		} else if (Ecart_Valeur < 0) {
			DOWN[compteur_RSI_V2] = Ecart_Valeur*-1;
			UP[compteur_RSI_V2] = 0;
		} 
	}
	
	var UP_Aff = document.getElementById("UP_Aff"); 
	UP_Aff.value = UP[compteur_RSI_V2];
	var DOWN_Aff = document.getElementById("DOWN_Aff"); 
	DOWN_Aff.value = DOWN[compteur_RSI_V2];
	
	// On verifi si on a assez de valeur pour lancer le calcul de l'indicateur
	if (compteur_RSI_V2 >= Periode_RSI+2) { // Calcul RSI en cours
		var Activation_RSI = document.getElementById("Activation_RSI"); 
		Activation_RSI.value = "Active";
		
		var Debut_RSI_V2 = compteur_RSI_V2-Periode_RSI;
		var Somme_UP = 0;
		var Somme_DOWN = 0;
		var UP_Boucle = 0;
		var DOWN_Boucle = 0;
		
		if (compteur_RSI_V2 == Periode_RSI+2) { // On fait la premiere moyenne
			for (var i=Debut_RSI_V2; i<=compteur_RSI_V2; i++) { // Boucle recuperation valeurs dans un tableau
				UP_Boucle = UP[i];
				DOWN_Boucle = DOWN[i];
				Somme_UP = Number(Somme_UP)+Number(UP_Boucle);
				Somme_DOWN = Number(Somme_DOWN)+Number(DOWN_Boucle);
			}
			AvgGain[compteur_RSI_V2] = Somme_UP/Periode_RSI;
			AvgLoss[compteur_RSI_V2] = Somme_DOWN/Periode_RSI;
		} else {
			AvgGain[compteur_RSI_V2] = (AvgGain[compteur_RSI_Moins_V2]*Periode_RSI_Moins+UP[compteur_RSI_V2])/Periode_RSI;
			AvgLoss[compteur_RSI_V2] = (AvgLoss[compteur_RSI_Moins_V2]*Periode_RSI_Moins+DOWN[compteur_RSI_V2])/Periode_RSI;
		}
		
		RS[compteur_RSI_V2] = AvgGain[compteur_RSI_V2]/AvgLoss[compteur_RSI_V2];
		
		if (AvgLoss[compteur_RSI_V2] == 0) {
			RSI_V2[compteur_RSI_V2] = 100;
		} else {
			RSI_V2[compteur_RSI_V2] = (100-(100/(1+RS[compteur_RSI_V2])));
		}
		var RSI_Aff = document.getElementById("Calcul_RSI"); 
		RSI_Aff.value = RSI_V2[compteur_RSI_V2];
		
	} else {
		// Profondeur pas suffisante
		var Activation_RSI = document.getElementById("Activation_RSI"); 
		Activation_RSI.value = "En cours de chargement";
	}

}