Discussion :

[sdecorme]

Bonjour,
J'ai un tableau de point dont les mini et maxi sont trop grand pour mes besoins. Malheureusement j'ai besoin des petites valeurs voila pourquoi une simple division n'est pas intéressante.
Actuellement j'ai un bout de code qui me permet de faire une sorte de compression malheureusement je n'arrive pas à atténuer autant que je voudrais ma courbe.
Dans la courbe ci-dessous on voit la donnée brute (verte) la donnée compressée(bleue) et une simple division (rouge) et on voit que le bleu et le vert reste commun dans les petites valeurs.


Voici le petit bout de code scilab qui m'a permis de faire ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
Alpha = 1.0;
Beta = 100.0;
Val = ValOri/3.8;
for i = 1:1:n
    Val3(i) = ((((Alpha / Beta) - 1) / Beta * abs(Val(i)) + 1.0) * ValOri(i));    
end
plot(ValOri,'g');//Green
plot(Val3,'b');//Blue
plot(Val,'r');//Red

et je n'arrive pas à optimiser ce code .
Si quelqu'un a une petite idée , ou un nom générique pour ce type de calcul je suis preneur.
Merci

[disedorgue]

Bonjour,

Peut-être qu'en utilisant une echelle logarithmique, tu auras ce que tu recherches.
En générale, ce genre d'échelle, permet d'atténuer les grandes valeurs vis à vis des petites valeurs.

[sdecorme]

Salut,
En effet le log pourrait tendre à atténuer les points extrêmes mais je cherche à recalculer tous mes points pour les sauvegarder.
Je ne sais pas comment je pourrais dans ma boucle inséré un Log avec un paramètre de valeur maximale.

[dourouc05]

Je ne sais pas comment je pourrais dans ma boucle inséré un Log avec un paramètre de valeur maximale.

Le logarithme posera problème, puisque tu as des valeurs à zéro (log 0, ça vaut, euh…) et même des négatives…

Sinon, si tu n'aimes pas tes pointes, tu peux aussi utiliser un maximum : si la valeur dépasse un seuil, hop, on la change pour mettre ce seuil (même chose dans les négatifs).

Ou alors tu multiplies par un facteur adaptatif : proche de 1 quand la valeur est faible, proche de zéro quand la valeur est infinie. Je pense à un truc comme (ne pas oublier les valeurs absolues, évidemment). Trois exemples en pièce jointe (le troisième exemple montre l'impact quand tu divises par une constante, ce qui te permettra d'atteindre ce que tu souhaites réellement comme applatissage).

[sdecorme]

Je me suis rendu compte de ce problème
Je viens de faire un essai en doublant ma formule dans ma boucle et ça fonctionne pas mal.
Rouge valeur originale
Vert première boucle
Bleu deuxième boucle
Ma valeur max finale ne devant pas dépasser +-18

[souviron34]

Ma valeur max finale ne devant pas dépasser +-18

Une simple règle de trois, hein ?

• (Maxi - Mini)_final = 36
  
  (Mini_final = -18, Maxi_final = 18)
  
  
  
• Nouvelle valeur = -18 + ((Valeur - Mini_initial) * 36 / (Maxi - Mini)_initial)

PS: quant à avoir une échelle log, c'est pas plus compliqué :

• Recalage de l'échelle en positif (> 0)
  
  Valeur_nouvelle = 1 + ((Valeur_initial - Mini_initial) / (Maxi - Mini)_initial)
  
  
  
• Nouvelle valeur = log(Valeur_nouvelle)
  
  (éventuellement là encore à ajuster si on veut que l'écart final soit entre -18 et 18)
  

[sdecorme]

Salut Souviron,
J'ai codé ta régle de 3 et elle ne fonctionne que si le mini et le maxi sont symétriques
Voici ma version pour les données non symétriques
Nouvelle valeur = Valeur * ( 36 / (Maxi - Mini)initial)
Voici une capture d'écran des différents calculs
Rouge données initiales
Bleu ma bidouille
Vert ta formule (tu vois le décalage)
Rose ta formule modifiée


Le problème de la régle de 3 c'est que ça écrase les petites valeurs que je voulais garder.
Je vais voir avec le Log comme ça se passe.

[souviron34]

Salut Souviron,
J'ai codé ta régle de 3 et elle ne fonctionne que si le mini et le maxi sont symétriques

Ben non, j'ai donné la formule symétrique parce que TOI tu donnais maxi = +/- 18

• D'une part c'est à appliquer à TOUTES les valeurs, pas juste les extrémales (ça compresse l'intervalle total entre -18 et +18)
  
  
  
  
• D'autre part, pour que ce soit "asymétrique", ou simplement une compression entre par exemple 0 et 1:
  
  Compression entre 0 et 1 :
  
  
  • Nouvelle valeur = (Valeur - Mini_initial) / (Maxi - Mini)_initial
    
    Si Valeur vaut Mini_initial ça vaut 0. Si Valeur vaut Maxi_initial ça vaut 1.
  
  
  
  
  Asymétrique entre -1 et 1 :
  
  
  • Nouvelle valeur = Valeur / (Maxi - Mini)_initial
    
    
    Si Valeur vaut Mini_initial ça vaut qque chose comme -0.xx, si Valeur vaut Maxi_initial ça vaut qque chose comme +0.yy
  
  
  
  

Ou alors j'ai mal compris ou tu t'es mal exprimé, et c'est juste les valeurs extrémales que tu veux réduire ???

[sdecorme]

Désolé si je me suis mal exprimé .
Les données sont asymétriques par contre en sortie je ne dois pas dépasser +-18.
Dans mon premier post exprime le fait de vouloir garder les faibles valeurs et atténuées les valeurs extrêmes.
Bref j'ai quand même réussi à faire ce que je voulais , mais je vais quand même prendre le temps de regarder avec les log par curiosité , ça peut me donner des idées.
Merci pour tes précisions

[souviron34]

Ah ok....


Comment détermines-tu le seuil "faible" vs "extrême" ??


Dans ce cas alors il suffit d'appliquer la règle de 3 à l'intervalle (seuil - valeur_extrême) :

Si valeur > seuil

valeur_nouvelle = seuil + ( (valeur - seuil) * (18-seuil) / (valeur_extrême - seuil) )

[wiwaxia]

Bonjour,

S'il s'agit de limiter les valeurs extrêmes d'une grandeur dépendant du temps x_(t), pourquoi ne pas recourir à l'une des fonctions suivantes (y = F_(x)) ?
a) y = y_m * th(x / a) ;
b) y = y_m * x / (a² + x²)^(1/2) ;
c) y = y_m * x / (a + |x]) ... s'il faut vraiment faire simple.

Leur graphe, symétrique par rapport à l'origine, présente deux paliers horizontaux d'ordonnée (+- y_m), et une pente maximale égale à (y_m / a).

PS: L'ajustage des constantes (puisque cela paraît important) est immédiat: on prendra y_m = 18 , et conviendra que pour les valeurs modérées couramment atteintes (|x] = b ~ 20 ?), (y) vaut par exemple 90 % du maximum, soit (0.9 * y_m) ; il vient alors:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
a) 0.9 = th(b / a)                    =>                    a = b / Argth(0.9) ;
b) 0.9 = b / (a<sup>2</sup> + b<sup>2</sup>)<sup>(1/2)</sup>             =>                    a = b * (0.9<sup>-2</sup> - 1)<sup>(1/2)</sup> ;
c) 0.9 = b / (a + b)                  =>                    a = b * (0.9<sup>-1</sup> - 1) .